import { ArgumentMetadata, ValidationPipe } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { CreateComponenteCostoDto, CreateItemEmbarqueDto, UpdateComponenteCostoDto, UpdateItemEmbarqueDto } from './dto/importaciones.dto';
import { ComprasService } from 'src/compras/compras.service';
import { GenerarCxPDto } from './dto/importaciones.dto';
import { ImportacionesCxPService } from './services/importaciones-cxp.service';
import { ImportacionesService } from './services/importaciones.service';

jest.mock('src/stock/tipos-movimiento-inventario', () => ({
  tipoMovimientoInventarioId: jest.fn((_tx: unknown, codigo: string) => Promise.resolve(`tipo-${codigo}`)),
}));

/** 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-1';
const UPDATED_AT = new Date('2026-10-01T12:00:00.000Z');
const UUID = '8b6c1ad4-3f3c-4f5e-9d0a-0c5a7c7a1111';
const VIN = '1HGCM82633A004352';

const cuerpo = async (promesa: Promise<unknown>) => {
  try {
    await promesa;
  } catch (e: any) {
    return { status: e.getStatus?.(), ...e.getResponse() };
  }
  throw new Error('No lanzó');
};

interface Opciones {
  estado?: string;
  perfil?: string;
  item?: Record<string, any> | null;
  costo?: Record<string, any> | null;
  duplicado?: Record<string, any> | null;
  vinculados?: number;
  documento?: { estado: string } | null;
  moneda?: Record<string, any>;
  proveedor?: Record<string, any> | null;
  createError?: unknown;
  base?: string;
}

function crear(opts: Opciones = {}) {
  const log: string[] = [];
  const embarque = { id: 'emb-1', empresa_id: EMPRESA, numero: 'IMP-2026-000001', estado: opts.estado ?? 'BORRADOR', perfil: opts.perfil ?? 'AUTOS', moneda_id: 'mon-usd', updated_at: UPDATED_AT, activo: true };
  const item = opts.item === undefined ? { id: 'item-1', empresa_id: EMPRESA, embarque_id: 'emb-1', chasis: VIN, orden: 10, updated_at: UPDATED_AT, activo: true } : opts.item;
  const costo =
    opts.costo === undefined
      ? { id: 'costo-1', empresa_id: EMPRESA, embarque_id: 'emb-1', concepto_id: 'con-1', moneda_id: null, proveedor_id: 'prov-1', cuenta_pagar_id: null, compra_id: null, gasto_id: null, asentado_documento_id: null, importe: 100, cotizacion: 1, es_directo: false, criterio_prorrateo: 'FOB', updated_at: UPDATED_AT, activo: true }
      : opts.costo;
  const tx: any = {
    $executeRaw: resuelve((_s: TemplateStringsArray, ...v: any[]) => {
      log.push(`lock:${String(v[0])}`);
    }),
    imp_config_empresa: { findUnique: jest.fn().mockResolvedValue({ empresa_id: EMPRESA, modulo_operativo_activo: true, perfil_activo: opts.perfil ?? 'AUTOS' }) },
    imp_embarques: {
      findFirst: resuelve(() => {
        log.push('leer-embarque');
        return embarque;
      }),
    },
    imp_embarque_items: {
      findFirst: resuelve((args: any) => (args?.where?.chasis ? opts.duplicado ?? null : item)),
      create: resuelve((args: any) => {
        if (opts.createError) throw opts.createError;
        return { id: 'item-nuevo', ...args.data };
      }),
      update: jest.fn(),
      aggregate: jest.fn().mockResolvedValue({ _max: { orden: 0 } }),
    },
    imp_componentes_costo: {
      findFirst: resuelve(() => costo),
      count: jest.fn().mockResolvedValue(opts.vinculados ?? 0),
      create: resuelve((args: any) => ({ id: 'costo-nuevo', ...args.data })),
      update: jest.fn(),
      updateMany: jest.fn(),
    },
    imp_conceptos_costo: { findFirst: jest.fn().mockResolvedValue({ id: 'con-1', codigo: 'FLETE' }), findUnique: jest.fn().mockResolvedValue({ nombre: 'Flete', codigo: 'FLETE' }) },
    moneda: { findUnique: jest.fn().mockResolvedValue(opts.moneda ?? { id: 'mon-usd', codigo: 'USD' }), findFirst: jest.fn().mockResolvedValue({ id: 'mon-pyg' }) },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: opts.base ?? 'mon-pyg' }) },
    proveedores: { findFirst: jest.fn().mockResolvedValue(opts.proveedor === undefined ? { id: 'prov-1', tipo_entidad: 'PROVEEDOR' } : opts.proveedor) },
    imp_despachos: { findFirst: jest.fn().mockResolvedValue({ id: 'des-1' }) },
    // El documento marcado en el costo (`asentado_documento_id`), con el estado de la prueba; el despacho no tiene otro.
    cont_documentos: {
      findFirst: jest.fn().mockResolvedValue(opts.documento ?? null),
      findMany: jest.fn().mockResolvedValue(opts.documento ? [{ id: 'doc-1', origen_tipo: null, origen_id: null, ...opts.documento }] : []),
    },
    suscripcion_modulos: { findFirst: jest.fn().mockResolvedValue({ id: 's' }) },
    imp_embarques_bitacora: { create: jest.fn() },
  };
  const prisma: any = { $transaction: jest.fn((cb: any) => cb(tx) as Promise<unknown>) };
  const costeo: any = { recalcular: jest.fn() };
  const service = new ImportacionesService(prisma, costeo, {} as any, {} as any, {} as any, {} as any, {} as any);
  jest.spyOn(service, 'findOne').mockResolvedValue({ id: 'emb-1' } as any);
  return { service, tx, log, costeo };
}

const dtoItem = (extra: Record<string, any> = {}): any => ({ chasis: VIN, marca: 'Honda', ...extra });
const dtoCosto = (extra: Record<string, any> = {}): any => ({ concepto_id: 'con-1', importe: 100, criterio_prorrateo: 'FOB', proveedor_id: 'prov-1', moneda_id: 'mon-usd', cotizacion: 7300, ...extra });

describe('Importaciones - ítems', () => {
  it('VIN de 16 caracteres → VIN_INVALIDO con campo chasis', async () => {
    const { service } = crear();
    const e = await cuerpo(service.addItem('emb-1', dtoItem({ chasis: VIN.slice(0, 16) }), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 400, codigo: 'VIN_INVALIDO', campo: 'chasis' });
  });

  it('AUTOS sin chasis → VIN_INVALIDO', async () => {
    const { service } = crear();
    const e = await cuerpo(service.addItem('emb-1', dtoItem({ chasis: '  ' }), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 400, codigo: 'VIN_INVALIDO', campo: 'chasis' });
  });

  it('la unicidad cuenta solo ítems activos de embarques activos: borrar un ítem y volver a cargar su chasis pasa (B15)', async () => {
    const { service, tx } = crear({ duplicado: null });
    await service.addItem('emb-1', dtoItem(), EMPRESA, 'u-1');
    const donde = tx.imp_embarque_items.findFirst.mock.calls.map((c: any) => c[0].where).find((w: any) => w.chasis);
    expect(donde).toMatchObject({ empresa_id: EMPRESA, chasis: VIN, activo: true, embarque: { activo: true } });
    expect(tx.imp_embarque_items.create).toHaveBeenCalledTimes(1);
  });

  it('chasis de otro embarque activo → CHASIS_DUPLICADO 409 con el número del embarque', async () => {
    const { service } = crear({ duplicado: { id: 'item-9', embarque: { id: 'emb-9', numero: 'IMP-2026-000009' } } });
    const e = await cuerpo(service.addItem('emb-1', dtoItem(), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'CHASIS_DUPLICADO', campo: 'chasis', embarque: { id: 'emb-9', numero: 'IMP-2026-000009' } });
  });

  it('P2002 del índice parcial (carrera entre embarques) → CHASIS_DUPLICADO', async () => {
    const p2002 = new Prisma.PrismaClientKnownRequestError('dup', { code: 'P2002', clientVersion: 'x' });
    const { service } = crear({ createError: p2002 });
    const e = await cuerpo(service.addItem('emb-1', dtoItem(), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'CHASIS_DUPLICADO' });
  });

  it('agregar ítem en DESPACHADO → ITEMS_CERRADOS', async () => {
    const { service } = crear({ estado: 'DESPACHADO' });
    const e = await cuerpo(service.addItem('emb-1', dtoItem(), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'ITEMS_CERRADOS' });
  });

  it('borrar ítem con costo directo vinculado (CxP, factura o gasto) → ITEM_CON_COSTOS_VINCULADOS', async () => {
    const { service, tx } = crear({ vinculados: 1 });
    const e = await cuerpo(service.removeItem('emb-1', 'item-1', EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'ITEM_CON_COSTOS_VINCULADOS' });
    const donde = tx.imp_componentes_costo.count.mock.calls[0][0].where;
    expect(donde).toMatchObject({ item_id: 'item-1', es_directo: true, activo: true });
    expect(JSON.stringify(donde.OR)).toContain('cuenta_pagar_id');
    expect(JSON.stringify(donde.OR)).toContain('compra_id');
    expect(JSON.stringify(donde.OR)).toContain('gasto_id');
    expect(tx.imp_embarque_items.update).not.toHaveBeenCalled();
  });

  it('borrar ítem sin vínculos lo da de baja', async () => {
    const { service, tx } = crear();
    await service.removeItem('emb-1', 'item-1', EMPRESA, 'u-1');
    expect(tx.imp_embarque_items.update).toHaveBeenCalled();
  });

  it('editar ítem sin updated_at → CAMPO_REQUERIDO; con otro updated_at → DATOS_CAMBIADOS', async () => {
    const { service } = crear();
    expect(await cuerpo(service.updateItem('emb-1', 'item-1', { marca: 'X' } as any, EMPRESA, 'u-1'))).toMatchObject({ status: 400, codigo: 'CAMPO_REQUERIDO', campo: 'updated_at' });
    expect(await cuerpo(service.updateItem('emb-1', 'item-1', { marca: 'X', updated_at: '2026-10-02T00:00:00.000Z' } as any, EMPRESA, 'u-1'))).toMatchObject({ status: 409, codigo: 'DATOS_CAMBIADOS' });
  });

  it('editar ítem en DESPACHADO → ITEMS_CERRADOS; con el updated_at vigente pasa', async () => {
    const cerrado = crear({ estado: 'DESPACHADO' });
    expect(await cuerpo(cerrado.service.updateItem('emb-1', 'item-1', { marca: 'X', updated_at: UPDATED_AT.toISOString() } as any, EMPRESA, 'u-1'))).toMatchObject({ codigo: 'ITEMS_CERRADOS' });
    const { service, tx } = crear();
    await service.updateItem('emb-1', 'item-1', { marca: 'X', updated_at: UPDATED_AT.toISOString() } as any, EMPRESA, 'u-1');
    expect(tx.imp_embarque_items.update).toHaveBeenCalled();
  });

  it('toma imp: antes de releer el embarque (alta, edición y baja)', async () => {
    for (const correr of [
      (s: ImportacionesService) => s.addItem('emb-1', dtoItem(), EMPRESA, 'u-1'),
      (s: ImportacionesService) => s.updateItem('emb-1', 'item-1', { marca: 'X', updated_at: UPDATED_AT.toISOString() } as any, EMPRESA, 'u-1'),
      (s: ImportacionesService) => s.removeItem('emb-1', 'item-1', EMPRESA, 'u-1'),
    ]) {
      const { service, log } = crear();
      await correr(service);
      expect(log.indexOf('lock:imp:emb-1')).toBeGreaterThanOrEqual(0);
      expect(log.indexOf('lock:imp:emb-1')).toBeLessThan(log.indexOf('leer-embarque'));
    }
  });
});

describe('Importaciones - costos', () => {
  const editar = (service: ImportacionesService, extra: Record<string, any> = {}) =>
    service.updateCosto('emb-1', 'costo-1', { descripcion: 'x', updated_at: UPDATED_AT.toISOString(), ...extra } as any, EMPRESA, 'u-1');

  it('editar costo con CxP → COSTO_CON_CXP', async () => {
    const { service } = crear({ costo: { id: 'costo-1', cuenta_pagar_id: 'cxp-1', updated_at: UPDATED_AT, concepto_id: 'con-1' } });
    expect(await cuerpo(editar(service))).toMatchObject({ status: 409, codigo: 'COSTO_CON_CXP' });
  });

  it('editar costo con factura o gasto → COSTO_CON_COMPROBANTE', async () => {
    const { service } = crear({ costo: { id: 'costo-1', compra_id: 'c-1', updated_at: UPDATED_AT, concepto_id: 'con-1' } });
    expect(await cuerpo(editar(service))).toMatchObject({ status: 409, codigo: 'COSTO_CON_COMPROBANTE' });
  });

  it('editar costo asentado (documento CONFIRMADO) → COSTO_ASENTADO; con documento REVERTIDO se edita', async () => {
    const asentado = crear({ costo: { id: 'costo-1', asentado_documento_id: 'doc-1', updated_at: UPDATED_AT, concepto_id: 'con-1' }, documento: { estado: 'CONFIRMADO' } });
    expect(await cuerpo(editar(asentado.service))).toMatchObject({ status: 409, codigo: 'COSTO_ASENTADO' });
    const revertido = crear({ costo: { id: 'costo-1', asentado_documento_id: 'doc-1', updated_at: UPDATED_AT, concepto_id: 'con-1', es_directo: false, criterio_prorrateo: 'FOB', importe: 100, cotizacion: 1 }, documento: { estado: 'REVERTIDO' } });
    await editar(revertido.service);
    expect(revertido.tx.imp_componentes_costo.update).toHaveBeenCalled();
  });

  it('editar o borrar un costo en LIBERADO → EMBARQUE_LIBERADO', async () => {
    const { service } = crear({ estado: 'LIBERADO' });
    expect(await cuerpo(editar(service))).toMatchObject({ status: 409, codigo: 'EMBARQUE_LIBERADO' });
    expect(await cuerpo(service.removeCosto('emb-1', 'costo-1', EMPRESA, 'u-1'))).toMatchObject({ codigo: 'EMBARQUE_LIBERADO' });
  });

  it('borrar un costo con CxP → COSTO_CON_CXP', async () => {
    const { service } = crear({ costo: { id: 'costo-1', cuenta_pagar_id: 'cxp-1', concepto_id: 'con-1' } });
    expect(await cuerpo(service.removeCosto('emb-1', 'costo-1', EMPRESA, 'u-1'))).toMatchObject({ codigo: 'COSTO_CON_CXP' });
  });

  it('editar costo sin updated_at → CAMPO_REQUERIDO; con otro → DATOS_CAMBIADOS', async () => {
    const { service } = crear();
    expect(await cuerpo(service.updateCosto('emb-1', 'costo-1', { descripcion: 'x' } as any, EMPRESA, 'u-1'))).toMatchObject({ status: 400, codigo: 'CAMPO_REQUERIDO', campo: 'updated_at' });
    expect(await cuerpo(editar(service, { updated_at: '2026-10-02T00:00:00.000Z' }))).toMatchObject({ status: 409, codigo: 'DATOS_CAMBIADOS' });
  });

  it('costo en USD con cotización 1 → COTIZACION_REQUERIDA; sin cotización y ≤ 0 también (B13)', async () => {
    const { service } = crear();
    for (const cotizacion of [1, undefined, 0, -5]) {
      const e = await cuerpo(service.addCosto('emb-1', dtoCosto({ cotizacion }), EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 400, codigo: 'COTIZACION_REQUERIDA', campo: 'cotizacion' });
    }
  });

  it('la base es la de la empresa: con base USD, un costo en USD sin cotización pasa y uno en PYG sin cotización → COTIZACION_REQUERIDA', async () => {
    const usd = crear({ base: 'mon-usd' });
    await usd.service.addCosto('emb-1', dtoCosto({ moneda_id: 'mon-usd', cotizacion: undefined }), EMPRESA, 'u-1');
    expect(usd.tx.imp_componentes_costo.create).toHaveBeenCalled();
    const pyg = crear({ base: 'mon-usd', moneda: { id: 'mon-pyg', codigo: 'PYG' } });
    const e = await cuerpo(pyg.service.addCosto('emb-1', dtoCosto({ moneda_id: 'mon-pyg', cotizacion: undefined }), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ codigo: 'COTIZACION_REQUERIDA', campo: 'cotizacion' });
  });

  it('sin moneda_id el costo es de la base de la empresa: con base USD no exige cotización; con base PYG tampoco', async () => {
    const { service, tx } = crear({ base: 'mon-usd' });
    await service.addCosto('emb-1', dtoCosto({ moneda_id: undefined, cotizacion: undefined }), EMPRESA, 'u-1');
    expect(tx.imp_componentes_costo.create).toHaveBeenCalled();
  });

  it('editar un costo legado con cotización 1 en USD: las notas pasan; tocar la cotización o el importe la valida', async () => {
    const legado = { id: 'costo-1', moneda_id: 'mon-usd', proveedor_id: 'prov-1', concepto_id: 'con-1', importe: 100, cotizacion: 1, es_directo: false, criterio_prorrateo: 'FOB', updated_at: UPDATED_AT };
    const a = crear({ costo: legado });
    await a.service.updateCosto('emb-1', 'costo-1', { observaciones: 'nota', updated_at: UPDATED_AT.toISOString() } as any, EMPRESA, 'u-1');
    expect(a.tx.imp_componentes_costo.update).toHaveBeenCalled();
    const b = crear({ costo: legado });
    const e = await cuerpo(b.service.updateCosto('emb-1', 'costo-1', { importe: 200, updated_at: UPDATED_AT.toISOString() } as any, EMPRESA, 'u-1'));
    expect(e).toMatchObject({ codigo: 'COTIZACION_REQUERIDA' });
  });

  it('editar un ítem legado con VIN corto: otros campos pasan; cambiar el chasis lo valida', async () => {
    const legado = { id: 'item-1', empresa_id: EMPRESA, embarque_id: 'emb-1', chasis: 'CORTO123', orden: 10, updated_at: UPDATED_AT };
    const a = crear({ item: legado });
    await a.service.updateItem('emb-1', 'item-1', { marca: 'X', updated_at: UPDATED_AT.toISOString() } as any, EMPRESA, 'u-1');
    expect(a.tx.imp_embarque_items.update).toHaveBeenCalled();
    const b = crear({ item: legado });
    const e = await cuerpo(b.service.updateItem('emb-1', 'item-1', { chasis: 'OTRO', updated_at: UPDATED_AT.toISOString() } as any, EMPRESA, 'u-1'));
    expect(e).toMatchObject({ codigo: 'VIN_INVALIDO' });
  });

  it('costo en guaraníes con cotización 1 pasa; en USD con 7300 pasa', async () => {
    const gs = crear({ moneda: { id: 'mon-pyg', codigo: 'PYG' } });
    await gs.service.addCosto('emb-1', dtoCosto({ moneda_id: 'mon-pyg', cotizacion: 1 }), EMPRESA, 'u-1');
    expect(gs.tx.imp_componentes_costo.create).toHaveBeenCalled();
    const usd = crear();
    await usd.service.addCosto('emb-1', dtoCosto(), EMPRESA, 'u-1');
    expect(usd.tx.imp_componentes_costo.create.mock.calls[0][0].data.importe_gs).toBe(730000);
  });

  it('costo directo sin ítem → COSTO_DIRECTO_SIN_ITEM', async () => {
    const { service } = crear();
    const e = await cuerpo(service.addCosto('emb-1', dtoCosto({ es_directo: true }), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 400, codigo: 'COSTO_DIRECTO_SIN_ITEM', campo: 'item_id' });
  });

  it('costo manual en DESPACHADO sin proveedor → PROVEEDOR_REQUERIDO', async () => {
    const { service } = crear({ estado: 'DESPACHADO' });
    const e = await cuerpo(service.addCosto('emb-1', dtoCosto({ proveedor_id: undefined }), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'PROVEEDOR_REQUERIDO', campo: 'proveedor_id' });
  });

  it('costo manual en LIBERADO → EMBARQUE_LIBERADO y en CERRADO → EMBARQUE_NO_EDITABLE', async () => {
    expect(await cuerpo(crear({ estado: 'LIBERADO' }).service.addCosto('emb-1', dtoCosto(), EMPRESA, 'u-1'))).toMatchObject({ codigo: 'EMBARQUE_LIBERADO' });
    expect(await cuerpo(crear({ estado: 'CERRADO' }).service.addCosto('emb-1', dtoCosto(), EMPRESA, 'u-1'))).toMatchObject({ codigo: 'EMBARQUE_NO_EDITABLE' });
  });

  it('proveedor ACREEDOR_VARIO → PROVEEDOR_ACREEDOR_VARIO', async () => {
    const { service } = crear({ proveedor: { id: 'prov-1', tipo_entidad: 'ACREEDOR_VARIO' } });
    expect(await cuerpo(service.addCosto('emb-1', dtoCosto(), EMPRESA, 'u-1'))).toMatchObject({ status: 400, codigo: 'PROVEEDOR_ACREEDOR_VARIO', campo: 'proveedor_id' });
  });

  it('gasto extra sin motivo → CAMPO_REQUERIDO con campo motivo_gasto_extra', async () => {
    const { service } = crear();
    const e = await cuerpo(service.addCosto('emb-1', dtoCosto({ es_gasto_extra: true, motivo_gasto_extra: '  ' }), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 400, codigo: 'CAMPO_REQUERIDO', campo: 'motivo_gasto_extra' });
  });

  it('es_posterior_cierre y cuenta_pagar_id los decide el servicio: el alta manual no los toma del cuerpo', async () => {
    const { service, tx } = crear();
    await service.addCosto('emb-1', dtoCosto({ es_posterior_cierre: true, cuenta_pagar_id: 'cxp-9' }), EMPRESA, 'u-1');
    const data = tx.imp_componentes_costo.create.mock.calls[0][0].data;
    expect(data.es_posterior_cierre).toBe(false);
    expect(data.cuenta_pagar_id).toBeUndefined();
  });

  it('toma imp: antes de releer el embarque (alta, edición y baja)', async () => {
    for (const correr of [
      (s: ImportacionesService) => s.addCosto('emb-1', dtoCosto(), EMPRESA, 'u-1'),
      (s: ImportacionesService) => editar(s, { cotizacion: 7300, moneda_id: 'mon-usd' }),
      (s: ImportacionesService) => s.removeCosto('emb-1', 'costo-1', EMPRESA, 'u-1'),
    ]) {
      const { service, log } = crear();
      await correr(service);
      expect(log.indexOf('lock:imp:emb-1')).toBeGreaterThanOrEqual(0);
      expect(log.indexOf('lock:imp:emb-1')).toBeLessThan(log.indexOf('leer-embarque'));
    }
  });
});

describe('Importaciones - DTO de ítems y costos con el pipe real', () => {
  const pipe = new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true });
  const patch = new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true, skipMissingProperties: true });
  const meta = (metatype: any): ArgumentMetadata => ({ type: 'body', metatype });

  it('el DTO de costo rechaza cuenta_pagar_id y es_posterior_cierre (B29)', async () => {
    await expect(pipe.transform({ concepto_id: UUID, importe: 1, cuenta_pagar_id: UUID }, meta(CreateComponenteCostoDto))).rejects.toMatchObject({ status: 400 });
    await expect(pipe.transform({ concepto_id: UUID, importe: 1, es_posterior_cierre: true }, meta(CreateComponenteCostoDto))).rejects.toMatchObject({ status: 400 });
    await expect(patch.transform({ cuenta_pagar_id: UUID, updated_at: null }, meta(UpdateComponenteCostoDto))).rejects.toMatchObject({ status: 400 });
  });

  it('el chasis de 16 llega al servicio (el DTO valida tipos) y uno de 41 no', async () => {
    await expect(pipe.transform({ chasis: VIN.slice(0, 16), fob_unit_usd: 1000 }, meta(CreateItemEmbarqueDto))).resolves.toBeDefined();
    await expect(pipe.transform({ chasis: 'A'.repeat(41), fob_unit_usd: 1000 }, meta(CreateItemEmbarqueDto))).rejects.toMatchObject({ status: 400 });
  });

  it('gasto extra sin motivo llega al servicio', async () => {
    await expect(pipe.transform({ concepto_id: UUID, importe: 1, es_gasto_extra: true }, meta(CreateComponenteCostoDto))).resolves.toBeDefined();
  });

  it('los PATCH aceptan updated_at ISO o null y rechazan otro texto', async () => {
    for (const dto of [UpdateItemEmbarqueDto, UpdateComponenteCostoDto]) {
      await expect(patch.transform({ updated_at: '2026-10-01T12:00:00.000Z' }, meta(dto))).resolves.toBeDefined();
      await expect(patch.transform({ updated_at: null }, meta(dto))).resolves.toBeDefined();
      await expect(patch.transform({ updated_at: 'ayer' }, meta(dto))).rejects.toMatchObject({ status: 400 });
    }
  });
});

describe('Importaciones - cuenta a pagar de un costo', () => {
  const costoUsd = (extra: Record<string, any> = {}) => ({
    id: 'costo-1', empresa_id: EMPRESA, embarque_id: 'emb-1', concepto_id: 'con-1', moneda_id: 'mon-usd', proveedor_id: 'prov-1',
    cuenta_pagar_id: null, importe: 1100.456, cotizacion: 7300, importe_gs: 8033329.8, activo: true, updated_at: UPDATED_AT, ...extra,
  });

  function crearCxp(opts: Opciones = {}) {
    const base = crear({ ...opts, costo: opts.costo === undefined ? (costoUsd() as any) : opts.costo });
    const { service, tx } = base;
    // `buildCuotasPersist` y su redondeo son los reales: lo que se afirma es lo que llega a la columna Decimal(18,2).
    const compras: any = Object.create(ComprasService.prototype);
    compras.persistCuentasPagar = jest.fn((_tx: unknown, params: any) => Promise.resolve(params.cuotas.map((_c: unknown, i: number) => ({ id: `cxp-${i + 1}` }))));
    const cxp = new ImportacionesCxPService(base.tx, compras, service);
    (cxp as any).prisma = { $transaction: (cb: any) => cb(tx) };
    return { ...base, cxp, compras };
  }
  const dto = (extra: Record<string, any> = {}): GenerarCxPDto => ({ fecha_emision: '2026-10-05', ...extra }) as GenerarCxPDto;

  it('CxP de un costo USD de un embarque PYG sale en USD con su cotización y monto = round(importe, 2)', async () => {
    const { cxp, compras, tx } = crearCxp({ base: 'mon-pyg' });
    await cxp.generarCxP('emb-1', 'costo-1', dto(), EMPRESA, 'u-1');
    const params = compras.persistCuentasPagar.mock.calls[0][1];
    expect(params).toMatchObject({ monedaId: 'mon-usd', proveedorId: 'prov-1', origenTipo: 'importacion', origenId: 'costo-1', embarqueId: 'emb-1' });
    expect(params.cuotas).toHaveLength(1);
    expect(params.cuotas[0].monto).toBe(1100.46);
    const bitacora = tx.imp_embarques_bitacora.create.mock.calls[0][0].data.detalle;
    expect(bitacora).toMatchObject({ importe: 1100.46, cotizacion: 7300 });
  });

  it('un costo en la moneda base sale en esa moneda y no pide cotización', async () => {
    const { cxp, compras } = crearCxp({ base: 'mon-pyg', costo: costoUsd({ moneda_id: null, cotizacion: 1, importe: 500000 }) as any });
    await cxp.generarCxP('emb-1', 'costo-1', dto(), EMPRESA, 'u-1');
    expect(compras.persistCuentasPagar.mock.calls[0][1]).toMatchObject({ monedaId: 'mon-pyg' });
    expect(compras.persistCuentasPagar.mock.calls[0][1].cuotas[0].monto).toBe(500000);
  });

  it('USD sin cotización válida (0 o 1) → COTIZACION_REQUERIDA, sin crear nada', async () => {
    for (const cotizacion of [0, 1]) {
      const { cxp, compras } = crearCxp({ costo: costoUsd({ cotizacion }) as any });
      const e = await cuerpo(cxp.generarCxP('emb-1', 'costo-1', dto(), EMPRESA, 'u-1'));
      expect(e).toMatchObject({ status: 400, codigo: 'COTIZACION_REQUERIDA', campo: 'cotizacion' });
      expect(compras.persistCuentasPagar).not.toHaveBeenCalled();
    }
  });

  it('dos Generar CxP: la primera guarda la cuota en cuenta_pagar_id y la segunda → COSTO_CON_CXP', async () => {
    const costo: Record<string, any> = costoUsd();
    const { cxp, compras, tx } = crearCxp({ costo });
    tx.imp_componentes_costo.update = jest.fn((args: any) => Object.assign(costo, args.data));
    const r = await cxp.generarCxP('emb-1', 'costo-1', dto({ numero_factura: ' F-1 ' }), EMPRESA, 'u-1');
    expect(r.cuenta_pagar_principal_id).toBe('cxp-1');
    expect(tx.imp_componentes_costo.update.mock.calls[0][0].data).toMatchObject({ cuenta_pagar_id: 'cxp-1', numero_factura: 'F-1' });
    const e = await cuerpo(cxp.generarCxP('emb-1', 'costo-1', dto(), EMPRESA, 'u-1'));
    expect(e).toMatchObject({ status: 409, codigo: 'COSTO_CON_CXP' });
    expect(compras.persistCuentasPagar).toHaveBeenCalledTimes(1);
  });

  it('toma el lock del embarque y relee el componente después', async () => {
    const { cxp, log, tx } = crearCxp();
    tx.imp_componentes_costo.findFirst = resuelve(() => {
      log.push('leer-componente');
      return costoUsd();
    });
    await cxp.generarCxP('emb-1', 'costo-1', dto(), EMPRESA, 'u-1');
    expect(log.indexOf('lock:imp:emb-1')).toBeGreaterThanOrEqual(0);
    expect(log.indexOf('lock:imp:emb-1')).toBeLessThan(log.indexOf('leer-componente'));
  });

  it('el proveedor es el del componente: sin proveedor, o uno que ya no es válido → CXP_SIN_PROVEEDOR', async () => {
    const sin = crearCxp({ costo: costoUsd({ proveedor_id: null }) as any });
    expect(await cuerpo(sin.cxp.generarCxP('emb-1', 'costo-1', dto(), EMPRESA, 'u-1'))).toMatchObject({ status: 400, codigo: 'CXP_SIN_PROVEEDOR', campo: 'proveedor_id' });
    const inactivo = crearCxp({ proveedor: null });
    expect(await cuerpo(inactivo.cxp.generarCxP('emb-1', 'costo-1', dto(), EMPRESA, 'u-1'))).toMatchObject({ status: 400, codigo: 'CXP_SIN_PROVEEDOR' });
  });

  it('un costo con factura o gasto → COSTO_CON_COMPROBANTE, sin crear la deuda otra vez', async () => {
    for (const vinculo of [{ compra_id: 'compra-1' }, { gasto_id: 'gasto-1' }]) {
      const { cxp, compras } = crearCxp({ costo: costoUsd(vinculo) as any });
      expect(await cuerpo(cxp.generarCxP('emb-1', 'costo-1', dto(), EMPRESA, 'u-1'))).toMatchObject({ status: 409, codigo: 'COSTO_CON_COMPROBANTE' });
      expect(compras.persistCuentasPagar).not.toHaveBeenCalled();
    }
  });

  it('importe 0 → CXP_SIN_IMPORTE', async () => {
    const { cxp } = crearCxp({ costo: costoUsd({ importe: 0 }) as any });
    expect(await cuerpo(cxp.generarCxP('emb-1', 'costo-1', dto(), EMPRESA, 'u-1'))).toMatchObject({ status: 400, codigo: 'CXP_SIN_IMPORTE' });
  });

  it('con el módulo operativo apagado → MODULO_INACTIVO (parked de T7)', async () => {
    const { cxp, tx } = crearCxp();
    tx.imp_config_empresa.findUnique.mockResolvedValue({ empresa_id: EMPRESA, modulo_operativo_activo: false });
    expect(await cuerpo(cxp.generarCxP('emb-1', 'costo-1', dto(), EMPRESA, 'u-1'))).toMatchObject({ status: 400, codigo: 'MODULO_INACTIVO' });
  });

  it('cuotas explícitas: la suma tiene que dar el importe redondeado', async () => {
    const { cxp, compras } = crearCxp();
    const cuotas = [
      { numero_cuota: 1, fecha_vencimiento: '2026-11-05', monto: 600 },
      { numero_cuota: 2, fecha_vencimiento: '2026-12-05', monto: 500.46 },
    ];
    await cxp.generarCxP('emb-1', 'costo-1', dto({ cuotas }), EMPRESA, 'u-1');
    expect(compras.persistCuentasPagar.mock.calls[0][1].cuotas.map((c: any) => c.monto)).toEqual([600, 500.46]);
    const mal = crearCxp();
    await expect(mal.cxp.generarCxP('emb-1', 'costo-1', dto({ cuotas: [{ ...cuotas[0], monto: 100 }] }), EMPRESA, 'u-1')).rejects.toMatchObject({ status: 400 });
  });

  it('el cuerpo viejo con proveedor_id se rechaza (T14→T22)', async () => {
    const pipe = new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true });
    await expect(pipe.transform({ fecha_emision: '2026-10-05', proveedor_id: UUID }, { type: 'body', metatype: GenerarCxPDto })).rejects.toMatchObject({ status: 400 });
    await expect(pipe.transform({ fecha_emision: '2026-10-05' }, { type: 'body', metatype: GenerarCxPDto })).resolves.toBeDefined();
  });
});
