import { Prisma } from '@prisma/client';
import { ROUTE_ARGS_METADATA } from '@nestjs/common/constants';
import { privilegiosDelUsuario } from 'src/auth/guards/algun-privilegio.guard';
import { estadoAsientoVigente, sqlEmbarquesConAsientoPendiente } from './estado-asiento';
import { ImportacionesController, PIPE_ESTADO_EMBARQUE, PIPE_ID_EMBARQUE } from './importaciones.controller';
import { ImportacionesBitacoraPresenter } from './services/importaciones-bitacora.presenter';
import { ImportacionesCxPService } from './services/importaciones-cxp.service';
import { ImportacionesService } from './services/importaciones.service';

/**
 * Lecturas de Importaciones (plan Task 15): listado con KPIs y filtros, detalle con acciones permitidas, `editable` y
 * documentos, contexto y bitácora. Incluye F5 (estado vigente del asiento) con la excepción F1 (corrección manual de
 * DOBA IMP-2026-000001), y los pendientes de T5 (F20), T11 (asentado con el asiento regenerado), T13 (B1 en liberar) y
 * T14 (generarCxP sobre un embarque eliminado).
 */

const EMPRESA = '11111111-1111-4111-8111-111111111111';
const OTRA = '99999999-9999-4999-8999-999999999999';
const EMB = '22222222-2222-4222-8222-222222222222';
const USUARIO = '33333333-3333-4333-8333-333333333333';
const DESP = '44444444-4444-4444-8444-444444444444';

const SOLO_VER = ['IMP_EMB_EMBARQUE_VER', 'IMP_COS_COSTO_VER', 'IMP_DES_DESPACHO_VER'];

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

interface Mundo {
  config?: Record<string, any> | null;
  superadmin?: boolean;
  privilegios?: string[];
  pendientes?: string[];
  filas?: Array<Record<string, any>>;
  total?: number;
  porEstado?: Array<Record<string, any>>;
  conPendiente?: number;
  embarque?: Record<string, any> | null;
  documentos?: Array<Record<string, any>>;
  cuotas?: Array<Record<string, any>>;
  cxp?: Array<Record<string, any>>;
  facturas?: Array<Record<string, any>>;
  gastos?: Array<Record<string, any>>;
  pagos?: Array<Record<string, any>>;
  contabilidad?: boolean;
  perfiles?: string[];
  bitacora?: Array<Record<string, any>>;
  /** Submódulos IMP_* excluidos en el plan de la empresa (`suscripcion_submodulos.active = false`). */
  excluidos?: string[];
  /** Privilegios cuyo submódulo es un addon sin contratar (capa 1.2). */
  addonsSinContratar?: string[];
  /** Moneda base: null = la empresa no tiene (ni PYG en el sistema). */
  monedaBase?: { id: string; codigo: string } | null;
  /** Sin fila en `imp_config_empresa`: si la suscripción tiene el módulo. */
  moduloEnSuscripcion?: boolean;
  tipoEmpresa?: string;
}

const embarqueBase = (extra: Record<string, any> = {}) => ({
  id: EMB,
  empresa_id: EMPRESA,
  numero: 'IMP-2026-000001',
  estado: 'DESPACHADO',
  perfil: 'AUTOS',
  activo: true,
  proveedor_id: 'p-zhang',
  proveedores: { id: 'p-zhang', tipo_entidad: 'PROVEEDOR_EXTERIOR', personas: { razon_social: 'ZHANGZHOU' } },
  moneda: { id: 'mon-pyg', codigo: 'PYG' },
  asiento_cierre_estado: null,
  asiento_cierre_codigo: null,
  asiento_cierre_mensaje: null,
  despacho: { id: DESP, estado: 'CONFIRMADO', numero_despacho: '26032IC04008192T', asiento_estado: 'GENERADO', asiento_codigo: null, asiento_mensaje: null },
  items: [
    { id: 'it-1', orden: 1, chasis: 'VIN1', producto: { id: 'prod-1', cod_producto: 'AUTO-1', descripcion: 'Auto 1' } },
    { id: 'it-2', orden: 2, chasis: 'VIN2', producto: null },
  ],
  componentes_costo: [
    {
      id: 'c-fob',
      item_id: null,
      es_directo: false,
      concepto: { codigo: 'FOB' },
      moneda: { codigo: 'PYG' },
      cuenta_pagar_id: null,
      compra_id: 'fac-1',
      gasto_id: null,
      compra: { id: 'fac-1', numero_factura: '001-001-0000123', estado: 'pendiente' },
      gasto: null,
      asentado_documento_id: null,
      asiento_estado: null,
    },
    {
      id: 'c-flete',
      item_id: 'it-1',
      es_directo: true,
      concepto: { codigo: 'FLETE' },
      moneda: { codigo: 'USD' },
      cuenta_pagar_id: 'cxp-1',
      compra_id: null,
      gasto_id: null,
      compra: null,
      gasto: null,
      asentado_documento_id: null,
      asiento_estado: null,
    },
    {
      id: 'c-desp',
      item_id: null,
      es_directo: false,
      concepto: { codigo: 'HONORARIOS' },
      moneda: { codigo: 'PYG' },
      cuenta_pagar_id: null,
      compra_id: null,
      gasto_id: 'gas-1',
      compra: null,
      gasto: { id: 'gas-1', numero_factura: '002-001-0000456', estado: 'registrado' },
      asentado_documento_id: null,
      asiento_estado: null,
    },
  ],
  ...extra,
});

function crear(m: Mundo = {}) {
  const coincideDoc = (d: Record<string, any>, o: Record<string, any>) =>
    Object.entries(o).every(([k, v]) => (v && typeof v === 'object' && 'in' in v ? (v.in as unknown[]).includes(d[k]) : d[k] === v));
  const prisma: any = {
    $transaction: jest.fn((arg: any) => (Array.isArray(arg) ? Promise.all(arg) : arg(prisma))),
    $queryRaw: jest.fn().mockResolvedValue((m.pendientes ?? []).map((id) => ({ id }))),
    imp_config_empresa: {
      findUnique: jest.fn().mockResolvedValue(m.config === undefined ? { modulo_operativo_activo: true, perfil_activo: 'AUTOS', criterio_cotizacion: 'DESPACHO' } : m.config),
      create: jest.fn(async ({ data }: any) => data),
    },
    usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: m.superadmin ?? false }), findMany: jest.fn().mockResolvedValue([]) },
    perfiles_privilegios: { findMany: jest.fn().mockResolvedValue((m.privilegios ?? SOLO_VER).map((codigo) => ({ privilegios: { codigo } }))) },
    imp_embarques: {
      findMany: jest.fn((args: any) => Promise.resolve(args?.distinct ? (m.perfiles ?? ['AUTOS']).map((perfil) => ({ perfil })) : (m.filas ?? []))),
      count: jest.fn((args: any) => Promise.resolve(args?.where?.AND ? (m.conPendiente ?? 0) : (m.total ?? (m.filas ?? []).length))),
      groupBy: jest.fn().mockResolvedValue(m.porEstado ?? []),
      findFirst: jest.fn((args: any) => {
        // Como Postgres: un id que no es uuid no se puede comparar con la columna (P2023).
        if (!/^[0-9a-f-]{36}$/.test(args.where.id)) {
          return Promise.reject(new Prisma.PrismaClientKnownRequestError('Error creating UUID', { code: 'P2023', clientVersion: 'x' }));
        }
        const e = m.embarque === undefined ? embarqueBase() : m.embarque;
        return Promise.resolve(e && args.where.empresa_id === e.empresa_id && args.where.id === e.id ? e : null);
      }),
    },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue(m.monedaBase === null ? null : { moneda_id: (m.monedaBase ?? { id: 'mon-pyg' }).id }) },
    moneda: { findUnique: jest.fn().mockResolvedValue(m.monedaBase === undefined ? { id: 'mon-pyg', codigo: 'PYG' } : m.monedaBase), findFirst: jest.fn().mockResolvedValue(null) },
    // Plan de la empresa (SubmoduloGuard y capa 1.2): por defecto, todo habilitado.
    empresas: { findUnique: jest.fn().mockResolvedValue({ type: m.tipoEmpresa ?? 'subsidiary' }) },
    submodulos: { findFirst: jest.fn(({ where }: any) => Promise.resolve({ id: `sub-${where.codigo}`, modulo_id: 'mod-imp', es_addon: false })) },
    suscripciones: { findFirst: jest.fn().mockResolvedValue({ id: 'sus-1' }) },
    suscripcion_modulos: {
      findFirst: jest.fn().mockResolvedValue(m.moduloEnSuscripcion === false ? null : { id: 'sm-1' }),
      findMany: jest.fn().mockResolvedValue([{ modulo_id: 'mod-imp' }]),
    },
    suscripcion_submodulos: {
      // Filas de la suscripción (contextoPlanEmpresa): las exclusiones. Addons contratados (capa 1.2): ninguno.
      findMany: jest.fn(({ where }: any) =>
        Promise.resolve(where.submodulo_id ? [] : (m.excluidos ?? []).map((c) => ({ submodulo_id: `sub-${c}`, active: false, fecha_fin_prueba: null }))),
      ),
    },
    privilegios: {
      findMany: jest.fn(({ where }: any) =>
        Promise.resolve(
          (where.codigo.in as string[]).map((codigo) => ({ codigo, submodulos: { id: `addon-${codigo}`, codigo: 'IMP_ADDON', es_addon: (m.addonsSinContratar ?? []).includes(codigo) } })),
        ),
      ),
    },
    cont_documentos: {
      findMany: jest.fn(({ where }: any) => Promise.resolve((m.documentos ?? []).filter((d) => d.empresa_id === where.empresa_id && where.OR.some((o: any) => coincideDoc(d, o))))),
      findFirst: jest.fn(({ where }: any) => Promise.resolve((m.documentos ?? []).find((d) => coincideDoc(d, where)) ?? null)),
    },
    cuentas_pagar: { findMany: jest.fn(({ where }: any) => Promise.resolve(where.origen_tipo === 'importacion' ? (m.cuotas ?? []) : (m.cxp ?? []))) },
    compra_cab: { findMany: jest.fn().mockResolvedValue(m.facturas ?? []) },
    gasto_cab: { findMany: jest.fn().mockResolvedValue(m.gastos ?? []) },
    tes_movimientos: { findMany: jest.fn().mockResolvedValue(m.pagos ?? []) },
    movimientos_inventario: { findMany: jest.fn().mockResolvedValue([]) },
    tipo_movimiento_inventario: { findMany: jest.fn().mockResolvedValue([]) },
    imp_embarques_bitacora: { findMany: jest.fn().mockResolvedValue(m.bitacora ?? []) },
  };
  const contabilidad: any = { tieneModuloContabilidad: jest.fn().mockResolvedValue(m.contabilidad ?? true) };
  const presenter = new ImportacionesBitacoraPresenter(prisma);
  const service = new ImportacionesService(prisma, {} as any, {} as any, contabilidad, presenter, {} as any, {} as any);
  return { service, prisma, contabilidad };
}

const accion = (acciones: Array<{ accion: string }>, nombre: string) => acciones.find((a) => a.accion === nombre);

describe('Importaciones · listado (findAll)', () => {
  it('page=2&limit=20 salta 20 (D13)', async () => {
    const { service, prisma } = crear({ total: 45 });
    const r = await service.findAll(EMPRESA, { page: '2', limit: '20' }, USUARIO);
    const args = prisma.imp_embarques.findMany.mock.calls[0][0];
    expect(args).toMatchObject({ skip: 20, take: 20 });
    expect(r).toMatchObject({ page: 2, limit: 20, total: 45, lastPage: 3 });
  });

  it('acciones_fila con solo VER: editar y eliminar false con SIN_PERMISO', async () => {
    const { service } = crear({ filas: [{ id: EMB, estado: 'BORRADOR', perfil: 'AUTOS' }] });
    const r = await service.findAll(EMPRESA, {}, USUARIO);
    expect(r.items[0].acciones_fila).toEqual({
      editar: expect.objectContaining({ accion: 'editar', permitida: false, codigo: 'SIN_PERMISO' }),
      eliminar: expect.objectContaining({ accion: 'eliminar', permitida: false, codigo: 'SIN_PERMISO' }),
    });
  });

  it('F20: acciones_fila.eliminar false desde DESPACHADO sin leer movimientos; antes, true', async () => {
    const filas = ['ARRIBADO', 'EN_DESPACHO', 'DESPACHADO', 'LIBERADO', 'CERRADO', 'SELLADO'].map((estado, i) => ({ id: `e-${i}`, estado, perfil: 'AUTOS' }));
    const { service, prisma } = crear({ filas, superadmin: true });
    const r = await service.findAll(EMPRESA, {}, USUARIO);
    const eliminar = Object.fromEntries(r.items.map((f: any) => [f.estado, f.acciones_fila.eliminar]));
    expect(eliminar.ARRIBADO.permitida).toBe(true);
    expect(eliminar.EN_DESPACHO.permitida).toBe(true);
    for (const e of ['DESPACHADO', 'LIBERADO', 'CERRADO', 'SELLADO']) {
      expect(eliminar[e]).toMatchObject({ permitida: false, codigo: 'EMBARQUE_CON_MOVIMIENTOS' });
    }
    expect(prisma.movimientos_inventario.findMany).not.toHaveBeenCalled();
  });

  it('acciones_fila.editar false con PERFIL_DISTINTO y con el módulo operativo apagado', async () => {
    const filas = [{ id: 'e-1', estado: 'BORRADOR', perfil: 'CONSUMO_MASIVO' }];
    const distinto = await crear({ filas, superadmin: true }).service.findAll(EMPRESA, {}, USUARIO);
    expect(distinto.items[0].acciones_fila.editar).toMatchObject({ permitida: false, codigo: 'PERFIL_DISTINTO' });
    const apagado = await crear({
      filas,
      superadmin: true,
      config: { modulo_operativo_activo: false, perfil_activo: 'CONSUMO_MASIVO', criterio_cotizacion: 'FACTURA' },
    }).service.findAll(EMPRESA, {}, USUARIO);
    expect(apagado.items[0].acciones_fila.editar).toMatchObject({ permitida: false, codigo: 'MODULO_INACTIVO' });
  });

  it('_count solo activos (B22)', async () => {
    const { service, prisma } = crear();
    await service.findAll(EMPRESA, {}, USUARIO);
    expect(prisma.imp_embarques.findMany.mock.calls[0][0].include._count).toEqual({
      select: { items: { where: { activo: true } }, componentes_costo: { where: { activo: true } } },
    });
  });

  it('stats sobre el filtro sin estado', async () => {
    const porEstado = [
      { estado: 'BORRADOR', _count: { _all: 2 }, _sum: { costo_total_gs: new Prisma.Decimal(0) } },
      { estado: 'EN_TRANSITO', _count: { _all: 3 }, _sum: { costo_total_gs: new Prisma.Decimal('1000.5') } },
      { estado: 'EN_DESPACHO', _count: { _all: 1 }, _sum: { costo_total_gs: new Prisma.Decimal('2000') } },
      { estado: 'DESPACHADO', _count: { _all: 4 }, _sum: { costo_total_gs: new Prisma.Decimal('3000') } },
      { estado: 'LIBERADO', _count: { _all: 5 }, _sum: { costo_total_gs: new Prisma.Decimal('376985027') } },
      { estado: 'CERRADO', _count: { _all: 6 }, _sum: { costo_total_gs: new Prisma.Decimal('10') } },
      { estado: 'SELLADO', _count: { _all: 7 }, _sum: { costo_total_gs: null } },
    ];
    const { service, prisma } = crear({ porEstado, conPendiente: 2, pendientes: [EMB, 'otro'] });
    const r = await service.findAll(EMPRESA, { estado: 'ARRIBADO', perfil: 'AUTOS', search: 'IMP' }, USUARIO);

    const whereLista = prisma.imp_embarques.findMany.mock.calls[0][0].where;
    const whereStats = prisma.imp_embarques.groupBy.mock.calls[0][0].where;
    expect(whereLista.estado).toBe('ARRIBADO');
    expect(whereStats.estado).toBeUndefined();
    expect(whereStats).toMatchObject({ empresa_id: EMPRESA, activo: true, perfil: 'AUTOS' });
    expect(whereStats.OR).toEqual(whereLista.OR);
    // El KPI de asientos cuenta los pendientes dentro del mismo filtro sin estado.
    expect(prisma.imp_embarques.count.mock.calls.find((c: any) => c[0].where.AND)[0].where).toEqual({ AND: [whereStats, { id: { in: [EMB, 'otro'] } }] });

    expect(r.stats).toEqual({
      abiertos: 15,
      en_transito: 3,
      en_despacho: 1,
      despachados_sin_liberar: 4,
      liberados_sin_cerrar: 5,
      asiento_pendiente: 2,
      costo_total: '376991037.5000',
    });
  });

  it('asiento_pendiente=true filtra los embarques con despacho o cierre PENDIENTE (la regla F5 en SQL)', async () => {
    const { service, prisma } = crear({
      pendientes: [EMB],
      filas: [
        { id: EMB, estado: 'LIBERADO', perfil: 'AUTOS' },
        { id: 'e-2', estado: 'BORRADOR', perfil: 'AUTOS' },
      ],
    });
    const r = await service.findAll(EMPRESA, { asiento_pendiente: 'true' }, USUARIO);
    expect(prisma.imp_embarques.findMany.mock.calls[0][0].where.id).toEqual({ in: [EMB] });
    expect(r.items.map((f: any) => [f.id, f.asiento_pendiente])).toEqual([
      [EMB, true],
      ['e-2', false],
    ]);
    // Una sola consulta por pedido, con la empresa como parámetro.
    expect(prisma.$queryRaw).toHaveBeenCalledTimes(1);
    expect(prisma.$queryRaw.mock.calls[0][0].values).toContain(EMPRESA);
  });

  it('desde–hasta sobre fecha_embarque (días UTC, como la columna @db.Date); mal formada → 400 FILTRO_INVALIDO', async () => {
    const { service, prisma } = crear();
    await service.findAll(EMPRESA, { desde: '2026-10-01', hasta: '2026-10-31' }, USUARIO);
    expect(prisma.imp_embarques.findMany.mock.calls[0][0].where.fecha_embarque).toEqual({ gte: new Date('2026-10-01T00:00:00.000Z'), lte: new Date('2026-10-31T00:00:00.000Z') });
    expect(prisma.imp_embarques.groupBy.mock.calls[0][0].where.fecha_embarque).toBeDefined();
    expect(await cuerpo(service.findAll(EMPRESA, { hasta: '2026-02-30' }, USUARIO))).toMatchObject({ status: 400, codigo: 'FILTRO_INVALIDO', campo: 'hasta' });
    expect(await cuerpo(service.findAll(EMPRESA, { desde: '01/10/2026' }, USUARIO))).toMatchObject({ status: 400, codigo: 'FILTRO_INVALIDO', campo: 'desde' });
  });

  it('estado=foo → 400 FILTRO_INVALIDO (pipe del controller y servicio)', async () => {
    const e = await cuerpo(Promise.resolve().then(() => (PIPE_ESTADO_EMBARQUE as any).transform('foo', { type: 'query', data: 'estado' })));
    expect(e).toMatchObject({ status: 400, codigo: 'FILTRO_INVALIDO', campo: 'estado' });
    await expect((PIPE_ESTADO_EMBARQUE as any).transform(undefined, { type: 'query', data: 'estado' })).resolves.toBeUndefined();
    await expect((PIPE_ESTADO_EMBARQUE as any).transform('DESPACHADO', { type: 'query', data: 'estado' })).resolves.toBe('DESPACHADO');
    const { service } = crear();
    expect(await cuerpo(service.findAll(EMPRESA, { estado: 'foo' }, USUARIO))).toMatchObject({ status: 400, codigo: 'FILTRO_INVALIDO', campo: 'estado' });
  });

  it('abiertos=true mantiene { items, total, page, limit, lastPage } (Facturas, Gastos, Tesorería) y suma stats', async () => {
    const { service, prisma } = crear({ filas: [{ id: EMB, estado: 'ARRIBADO', perfil: 'AUTOS' }] });
    const r = await service.findAll(EMPRESA, { abiertos: 'true', limit: '100' }, USUARIO);
    expect(Object.keys(r).sort()).toEqual(['items', 'lastPage', 'limit', 'page', 'stats', 'total']);
    expect(r).toMatchObject({ total: 1, page: 1, limit: 100, lastPage: 1 });
    expect(prisma.imp_embarques.findMany.mock.calls[0][0].where.estado).toEqual({ notIn: ['CERRADO', 'SELLADO'] });
    expect(prisma.imp_embarques.groupBy.mock.calls[0][0].where.estado).toBeUndefined();
  });

  it('T16: perfil=foo → 400 FILTRO_INVALIDO con campo perfil; los dos perfiles pasan', async () => {
    const { service } = crear();
    expect(await cuerpo(service.findAll(EMPRESA, { perfil: 'foo' }, USUARIO))).toMatchObject({
      status: 400,
      codigo: 'FILTRO_INVALIDO',
      campo: 'perfil',
      message: 'El perfil no es válido. Usá uno de: Autos, Consumo masivo.',
    });
    for (const perfil of ['AUTOS', 'CONSUMO_MASIVO']) await expect(service.findAll(EMPRESA, { perfil }, USUARIO)).resolves.toBeDefined();
  });

  it('T16: acciones_fila con IMP_EMBARQUES excluido → SUBMODULO_NO_DISPONIBLE con el mensaje del guard (aunque tenga el permiso)', async () => {
    const filas = [{ id: EMB, estado: 'BORRADOR', perfil: 'AUTOS' }];
    const r = await crear({ filas, privilegios: ['IMP_EMB_EMBARQUE_EDITAR', 'IMP_EMB_EMBARQUE_ELIMINAR'], excluidos: ['IMP_EMBARQUES'] }).service.findAll(EMPRESA, {}, USUARIO);
    expect(r.items[0].acciones_fila.editar).toEqual({
      accion: 'editar',
      permitida: false,
      codigo: 'SUBMODULO_NO_DISPONIBLE',
      motivo: 'El submódulo "IMP_EMBARQUES" está deshabilitado para esta empresa',
    });
  });

  it('los privilegios se leen una vez por pedido', async () => {
    const filas = ['BORRADOR', 'ARRIBADO', 'LIBERADO'].map((estado, i) => ({ id: `e-${i}`, estado, perfil: 'AUTOS' }));
    const { service, prisma } = crear({ filas });
    await service.findAll(EMPRESA, {}, USUARIO);
    expect(prisma.perfiles_privilegios.findMany).toHaveBeenCalledTimes(1);
  });
});

describe('Importaciones · detalle (findOne)', () => {
  it('T16 · capa 1.2 y SubmoduloGuard en acciones_permitidas: usuario normal y superadmin, como los guards', async () => {
    const TODO_COSTO = ['IMP_COS_COSTO_CREAR', 'IMP_EMB_EMBARQUE_EDITAR'];
    const normal = await crear({ privilegios: TODO_COSTO, excluidos: ['IMP_COSTOS'] }).service.findOne(EMB, EMPRESA, USUARIO);
    expect(accion(normal.acciones_permitidas, 'agregar_costo')).toMatchObject({
      permitida: false,
      codigo: 'SUBMODULO_NO_DISPONIBLE',
      motivo: 'El submódulo "IMP_COSTOS" está deshabilitado para esta empresa',
    });
    expect(accion(normal.acciones_permitidas, 'editar')).toMatchObject({ permitida: true });
    // El superadmin saltea SubmoduloGuard…
    const superadmin = await crear({ superadmin: true, excluidos: ['IMP_COSTOS'] }).service.findOne(EMB, EMPRESA, USUARIO);
    expect(accion(superadmin.acciones_permitidas, 'agregar_costo')).toMatchObject({ permitida: true });
    // …pero no la capa 1.2 (addon no contratado), igual que PermissionGuard.
    const addon = await crear({ superadmin: true, addonsSinContratar: ['IMP_COS_COSTO_CREAR'] }).service.findOne(EMB, EMPRESA, USUARIO);
    expect(accion(addon.acciones_permitidas, 'agregar_costo')).toMatchObject({
      permitida: false,
      codigo: 'SUBMODULO_NO_DISPONIBLE',
      motivo: 'El submódulo "IMP_ADDON" requiere un addon no contratado en su plan',
    });
  });

  it("findOne con 'e2e-1' o de otra empresa → 404 EMBARQUE_NO_ENCONTRADO (Review Focus)", async () => {
    const { service, prisma } = crear();
    expect(await cuerpo(service.findOne('e2e-1', EMPRESA, USUARIO))).toMatchObject({ status: 404, codigo: 'EMBARQUE_NO_ENCONTRADO' });
    expect(prisma.cont_documentos.findMany).not.toHaveBeenCalled();
    expect(await cuerpo(service.findOne(EMB, OTRA, USUARIO))).toMatchObject({ status: 404, codigo: 'EMBARQUE_NO_ENCONTRADO' });
    // El pipe del controller corta antes del servicio.
    const e = await cuerpo(Promise.resolve().then(() => PIPE_ID_EMBARQUE.transform('e2e-1', { type: 'param', data: 'id' })));
    expect(e).toMatchObject({ status: 404, codigo: 'EMBARQUE_NO_ENCONTRADO' });
    await expect(PIPE_ID_EMBARQUE.transform(EMB, { type: 'param', data: 'id' })).resolves.toBe(EMB);
  });

  it('todo :id de embarque pasa por PIPE_ID_EMBARQUE; estado por PIPE_ESTADO_EMBARQUE; GET contexto existe', () => {
    const proto = ImportacionesController.prototype as any;
    const rutas = Object.getOwnPropertyNames(proto)
      .filter((n) => n !== 'constructor')
      .map((n) => ({ n, ruta: Reflect.getMetadata('path', proto[n]) as string }));
    const deEmbarque = rutas.filter((r) => r.ruta?.startsWith('embarques/:id'));
    expect(deEmbarque.length).toBeGreaterThanOrEqual(20);
    for (const { n } of deEmbarque) {
      const args: Array<{ data: string; pipes: unknown[] }> = Object.values(Reflect.getMetadata(ROUTE_ARGS_METADATA, ImportacionesController, n) ?? {});
      const id = args.find((a) => a.data === 'id');
      expect({ n, pipe: id?.pipes.includes(PIPE_ID_EMBARQUE) }).toEqual({ n, pipe: true });
    }
    const listado: Array<{ data: string; pipes: unknown[] }> = Object.values(Reflect.getMetadata(ROUTE_ARGS_METADATA, ImportacionesController, 'findAll'));
    expect(listado.find((a) => a.data === 'estado')?.pipes).toContain(PIPE_ESTADO_EMBARQUE);
    expect(rutas.find((r) => r.n === 'contexto')?.ruta).toBe('contexto');
  });

  it('findOne: compra, gasto, cuotas_cxp, documentos, editable y acciones_permitidas para un perfil solo VER', async () => {
    const { service } = crear({
      documentos: [{ id: 'doc-des', empresa_id: EMPRESA, origen_tipo: 'imp_despacho', origen_id: DESP, estado: 'CONFIRMADO', asiento: { numero: 231 } }],
      cuotas: [
        {
          id: 'cxp-1',
          origen_id: 'c-flete',
          numero_cuota: 1,
          monto_original: new Prisma.Decimal('1500.00'),
          saldo_pendiente: new Prisma.Decimal('500.00'),
          fecha_vencimiento: new Date('2026-11-30T00:00:00.000Z'),
          estado: 'parcial',
        },
      ],
      facturas: [
        {
          id: 'fac-1',
          numero_factura: '001-001-0000123',
          estado: 'pendiente',
          anulado: false,
          total: new Prisma.Decimal('376985027'),
          fecha_emision: new Date('2026-10-01T00:00:00.000Z'),
          moneda: { codigo: 'PYG' },
        },
      ],
      gastos: [
        {
          id: 'gas-1',
          numero_factura: '002-001-0000456',
          estado: 'registrado',
          anulado: false,
          total: new Prisma.Decimal('1100000'),
          fecha_emision: new Date('2026-10-05T00:00:00.000Z'),
          moneda: { codigo: 'PYG' },
        },
      ],
      cxp: [
        {
          id: 'cxp-1',
          numero_cuota: 1,
          total_cuotas: 1,
          estado: 'parcial',
          monto_original: new Prisma.Decimal('1500.00'),
          saldo_pendiente: new Prisma.Decimal('500.00'),
          fecha_vencimiento: new Date('2026-11-30T00:00:00.000Z'),
          origen_tipo: 'importacion',
          origen_id: 'c-flete',
          moneda: { codigo: 'USD' },
          compra_cab: null,
          imp_componentes_costo: [{ numero_factura: 'F-77' }],
        },
      ],
      pagos: [
        {
          id: 'tes-1',
          referencia: 'TRF-9',
          estado: 'CONFIRMADO',
          monto: new Prisma.Decimal('500'),
          fecha: new Date('2026-10-10T00:00:00.000Z'),
          tipo_pago_importacion: 'DESPACHO',
          cuenta: { moneda: 'PYG' },
        },
      ],
    });
    const d: any = await service.findOne(EMB, EMPRESA, USUARIO);

    const [fob, flete, honorarios] = d.componentes_costo;
    expect(fob.compra).toEqual({ id: 'fac-1', numero_factura: '001-001-0000123', estado: 'pendiente' });
    expect(honorarios.gasto).toEqual({ id: 'gas-1', numero: '002-001-0000456', estado: 'registrado' });
    expect(flete.cuotas_cxp).toEqual([
      {
        id: 'cxp-1',
        numero_cuota: 1,
        monto: new Prisma.Decimal('1500.00'),
        saldo: new Prisma.Decimal('500.00'),
        fecha_vencimiento: new Date('2026-11-30T00:00:00.000Z'),
        estado: 'parcial',
      },
    ]);
    expect(fob.editable).toEqual({ editable: false, borrable: false, codigo: 'COSTO_CON_COMPROBANTE', motivo: expect.any(String) });
    expect(flete.editable).toMatchObject({ editable: false, codigo: 'COSTO_CON_CXP' });

    // Ítems cerrados desde DESPACHADO; el producto con su código.
    expect(d.items[0].editable).toMatchObject({ editable: false, borrable: false, codigo: 'ITEMS_CERRADOS' });
    expect(d.items[0].producto).toMatchObject({ id: 'prod-1', codigo: 'AUTO-1', descripcion: 'Auto 1' });

    expect(d.documentos.facturas).toEqual([
      {
        id: 'fac-1',
        numero: '001-001-0000123',
        estado: 'pendiente',
        anulado: false,
        total: new Prisma.Decimal('376985027'),
        fecha: new Date('2026-10-01T00:00:00.000Z'),
        moneda: { codigo: 'PYG' },
      },
    ]);
    expect(d.documentos.gastos[0]).toMatchObject({ id: 'gas-1', numero: '002-001-0000456', moneda: { codigo: 'PYG' } });
    expect(d.documentos.cxp[0]).toMatchObject({ id: 'cxp-1', numero: 'F-77', estado: 'parcial', moneda: { codigo: 'USD' } });
    expect(d.documentos.pagos_tesoreria[0]).toMatchObject({ id: 'tes-1', numero: 'TRF-9', estado: 'CONFIRMADO', moneda: { codigo: 'PYG' } });

    expect(d.proveedores.tipo_entidad).toBe('PROVEEDOR_EXTERIOR');
    expect(d.despacho.asiento).toEqual({ estado: 'GENERADO', documento_id: 'doc-des', numero: '231' });

    expect(d.acciones_permitidas.length).toBeGreaterThan(0);
    for (const a of d.acciones_permitidas) expect(a).toMatchObject({ permitida: false, codigo: 'SIN_PERMISO', motivo: expect.any(String) });
    expect(d.acciones_permitidas.map((a: any) => a.accion)).toEqual(['editar', 'eliminar', 'agregar_costo', 'liberar']);

    expect(d.contexto).toEqual({
      modulo_operativo_activo: true,
      perfil_activo: 'AUTOS',
      criterio_cotizacion: 'DESPACHO',
      moneda_base: { id: 'mon-pyg', codigo: 'PYG' },
      tiene_contabilidad: true,
      puede_configurar: false,
      perfiles_en_uso: ['AUTOS'],
    });
  });

  it('F1: el despacho corregido a mano (CORRECCION_MANUAL, documento REVERTIDO) sigue GENERADO y no ofrece reintento (DOBA IMP-2026-000001)', async () => {
    const despacho = {
      id: DESP,
      estado: 'CONFIRMADO',
      numero_despacho: '26032IC04008192T',
      asiento_estado: 'GENERADO',
      asiento_codigo: 'CORRECCION_MANUAL',
      asiento_mensaje: 'Corregido a mano con el asiento N° 231.',
    };
    const { service } = crear({
      superadmin: true,
      embarque: embarqueBase({ estado: 'LIBERADO', despacho }),
      documentos: [{ id: 'doc-viejo', empresa_id: EMPRESA, origen_tipo: 'imp_despacho', origen_id: DESP, estado: 'REVERTIDO', asiento: { numero: 120 } }],
    });
    const d: any = await service.findOne(EMB, EMPRESA, USUARIO);
    expect(d.despacho.asiento).toEqual({ estado: 'GENERADO', codigo: 'CORRECCION_MANUAL', mensaje: 'Corregido a mano con el asiento N° 231.' });
    expect(accion(d.acciones_permitidas, 'reintentar_asiento_despacho')).toBeUndefined();
    expect(accion(d.acciones_permitidas, 'cerrar')).toMatchObject({ permitida: true });
  });

  it('T13 · B1: liberar refleja el estado VIGENTE del asiento del despacho', async () => {
    const despacho = (extra: Record<string, any>) => ({ id: DESP, estado: 'CONFIRMADO', numero_despacho: 'D-1', asiento_codigo: null, asiento_mensaje: null, ...extra });
    // Columna GENERADO, pero el documento se revirtió desde Contabilidad › Asientos sin reemplazo.
    const revertido = crear({
      superadmin: true,
      embarque: embarqueBase({ despacho: despacho({ asiento_estado: 'GENERADO' }) }),
      documentos: [{ id: 'doc-1', empresa_id: EMPRESA, origen_tipo: 'imp_despacho', origen_id: DESP, estado: 'REVERTIDO' }],
    });
    const r: any = await revertido.service.findOne(EMB, EMPRESA, USUARIO);
    expect(r.despacho.asiento).toMatchObject({ estado: 'PENDIENTE', codigo: 'ASIENTO_REVERTIDO' });
    expect(accion(r.acciones_permitidas, 'liberar')).toMatchObject({ permitida: false, codigo: 'ASIENTO_DESPACHO_PENDIENTE' });
    expect(accion(r.acciones_permitidas, 'reintentar_asiento_despacho')).toMatchObject({ permitida: true });

    // Columna PENDIENTE, pero el contador lo regeneró desde Conciliación: hay un documento CONFIRMADO.
    const regenerado = crear({
      superadmin: true,
      embarque: embarqueBase({ despacho: despacho({ asiento_estado: 'PENDIENTE', asiento_codigo: 'MAPEO_FALTANTE' }) }),
      documentos: [{ id: 'doc-2', empresa_id: EMPRESA, origen_tipo: 'imp_despacho', origen_id: DESP, estado: 'CONFIRMADO', asiento: { numero: 300 } }],
    });
    const g: any = await regenerado.service.findOne(EMB, EMPRESA, USUARIO);
    expect(g.despacho.asiento).toEqual({ estado: 'GENERADO', documento_id: 'doc-2', numero: '300' });
    expect(accion(g.acciones_permitidas, 'liberar')).toMatchObject({ permitida: true });
    expect(accion(g.acciones_permitidas, 'reintentar_asiento_despacho')).toBeUndefined();

    // Sin Contabilidad no bloquea.
    const sinConta = crear({ superadmin: true, contabilidad: false, embarque: embarqueBase({ despacho: despacho({ asiento_estado: 'PENDIENTE' }) }) });
    const s: any = await sinConta.service.findOne(EMB, EMPRESA, USUARIO);
    expect(accion(s.acciones_permitidas, 'liberar')).toMatchObject({ permitida: true });
  });

  it('T13 · B1: liberarEmbarque usa el mismo estado vigente (columna GENERADO con el documento revertido → 409)', async () => {
    const { service, prisma } = crear({ documentos: [{ id: 'doc-1', empresa_id: EMPRESA, origen_tipo: 'imp_despacho', origen_id: DESP, estado: 'REVERTIDO' }] });
    prisma.$executeRaw = jest.fn().mockResolvedValue(1);
    prisma.imp_despachos = { findFirst: jest.fn().mockResolvedValue({ id: DESP, asiento_estado: 'GENERADO', asiento_codigo: null, asiento_mensaje: null }) };
    prisma.imp_embarques.findFirst = jest.fn().mockResolvedValue({ id: EMB, empresa_id: EMPRESA, estado: 'DESPACHADO', activo: true });
    const e = await cuerpo(service.liberarEmbarque(EMB, { deposito_destino_id: 'dep-1' } as any, EMPRESA, USUARIO));
    expect(e).toMatchObject({ status: 409, codigo: 'ASIENTO_DESPACHO_PENDIENTE' });
  });

  it('T11 · asentado: con el asiento del despacho regenerado (componente apuntando al documento viejo), el costo sigue asentado', async () => {
    const manual = (extra: Record<string, any>) => ({
      id: 'c-man',
      item_id: null,
      es_directo: false,
      concepto: { codigo: 'FLETE' },
      moneda: { codigo: 'PYG' },
      cuenta_pagar_id: null,
      compra_id: null,
      gasto_id: null,
      compra: null,
      gasto: null,
      asiento_estado: null,
      ...extra,
    });
    // Regenerado: el viejo está REVERTIDO y desvinculado; el del despacho, nuevo y CONFIRMADO.
    const regenerado = crear({
      embarque: embarqueBase({ componentes_costo: [manual({ asentado_documento_id: 'doc-viejo' })] }),
      documentos: [
        { id: 'doc-viejo', empresa_id: EMPRESA, origen_tipo: null, origen_id: null, estado: 'REVERTIDO' },
        { id: 'doc-nuevo', empresa_id: EMPRESA, origen_tipo: 'imp_despacho', origen_id: DESP, estado: 'CONFIRMADO' },
      ],
    });
    const r: any = await regenerado.service.findOne(EMB, EMPRESA, USUARIO);
    expect(r.componentes_costo[0]).toMatchObject({ asentado: true, editable: { editable: false, codigo: 'COSTO_ASENTADO' } });

    // Revertido sin reemplazo: B3, editable.
    const revertido = crear({
      embarque: embarqueBase({ componentes_costo: [manual({ asentado_documento_id: 'doc-viejo' })] }),
      documentos: [{ id: 'doc-viejo', empresa_id: EMPRESA, origen_tipo: 'imp_despacho', origen_id: DESP, estado: 'REVERTIDO' }],
    });
    const v: any = await revertido.service.findOne(EMB, EMPRESA, USUARIO);
    expect(v.componentes_costo[0]).toMatchObject({ asentado: false, editable: { editable: true, borrable: true } });

    // Complementario (lleva asiento_estado): su asiento propio regenerado lo asienta; el del despacho no cuenta.
    const complementario = crear({
      embarque: embarqueBase({ componentes_costo: [manual({ asentado_documento_id: 'doc-comp-viejo', asiento_estado: 'GENERADO' })] }),
      documentos: [
        { id: 'doc-comp-viejo', empresa_id: EMPRESA, origen_tipo: null, origen_id: null, estado: 'REVERTIDO' },
        { id: 'doc-des', empresa_id: EMPRESA, origen_tipo: 'imp_despacho', origen_id: DESP, estado: 'CONFIRMADO' },
      ],
    });
    expect(((await complementario.service.findOne(EMB, EMPRESA, USUARIO)) as any).componentes_costo[0].asentado).toBe(false);
    const compRegenerado = crear({
      embarque: embarqueBase({ componentes_costo: [manual({ asentado_documento_id: 'doc-comp-viejo', asiento_estado: 'GENERADO' })] }),
      documentos: [
        { id: 'doc-comp-viejo', empresa_id: EMPRESA, origen_tipo: null, origen_id: null, estado: 'REVERTIDO' },
        { id: 'doc-comp-nuevo', empresa_id: EMPRESA, origen_tipo: 'imp_componente', origen_id: 'c-man', estado: 'CONFIRMADO' },
      ],
    });
    expect(((await compRegenerado.service.findOne(EMB, EMPRESA, USUARIO)) as any).componentes_costo[0].asentado).toBe(true);
  });

  it('T11 · asentado: la edición del costo usa el mismo criterio (asiento regenerado → 409 COSTO_ASENTADO)', async () => {
    const { service, prisma } = crear({
      documentos: [
        { id: 'doc-viejo', empresa_id: EMPRESA, origen_tipo: null, origen_id: null, estado: 'REVERTIDO' },
        { id: 'doc-nuevo', empresa_id: EMPRESA, origen_tipo: 'imp_despacho', origen_id: DESP, estado: 'CONFIRMADO' },
      ],
    });
    const updatedAt = new Date('2026-10-01T12:00:00.000Z');
    prisma.$executeRaw = jest.fn().mockResolvedValue(1);
    prisma.imp_embarques.findFirst = jest.fn().mockResolvedValue({ id: EMB, empresa_id: EMPRESA, estado: 'DESPACHADO', activo: true });
    prisma.imp_despachos = { findFirst: jest.fn().mockResolvedValue({ id: DESP }) };
    prisma.imp_componentes_costo = {
      findFirst: jest
        .fn()
        .mockResolvedValue({
          id: 'c-man',
          embarque_id: EMB,
          empresa_id: EMPRESA,
          cuenta_pagar_id: null,
          compra_id: null,
          gasto_id: null,
          asentado_documento_id: 'doc-viejo',
          asiento_estado: null,
          updated_at: updatedAt,
        }),
    };
    const e = await cuerpo(service.removeCosto(EMB, 'c-man', EMPRESA, USUARIO));
    expect(e).toMatchObject({ status: 409, codigo: 'COSTO_ASENTADO' });
  });
});

describe('Importaciones · contexto', () => {
  it('contexto con moneda_base, tiene_contabilidad, perfiles_en_uso y puede_configurar', async () => {
    const { service, prisma } = crear({ privilegios: [...SOLO_VER, 'IMP_CFG_CONFIG_EDITAR'], perfiles: ['CONSUMO_MASIVO', 'AUTOS'], contabilidad: false });
    const c = await service.contexto(EMPRESA, USUARIO);
    expect(c).toEqual({
      modulo_operativo_activo: true,
      perfil_activo: 'AUTOS',
      criterio_cotizacion: 'DESPACHO',
      moneda_base: { id: 'mon-pyg', codigo: 'PYG' },
      tiene_contabilidad: false,
      puede_configurar: true,
      perfiles_en_uso: ['AUTOS', 'CONSUMO_MASIVO'],
    });
    expect(prisma.imp_embarques.findMany.mock.calls[0][0]).toMatchObject({ where: { empresa_id: EMPRESA, activo: true }, distinct: ['perfil'] });
    expect((await crear().service.contexto(EMPRESA, USUARIO)).puede_configurar).toBe(false);
    expect((await crear({ superadmin: true, privilegios: [] }).service.contexto(EMPRESA, USUARIO)).puede_configurar).toBe(true);
  });

  it('T16: sin moneda base → 409 MONEDA_BASE_NO_CONFIGURADA (no codigo vacío)', async () => {
    expect(await cuerpo(crear({ monedaBase: null }).service.contexto(EMPRESA, USUARIO))).toMatchObject({ status: 409, codigo: 'MONEDA_BASE_NO_CONFIGURADA' });
  });

  it('T16: sin fila de configuración, operativo según la suscripción (lo que crearía la primera escritura), sin crearla', async () => {
    const con = crear({ config: null });
    expect((await con.service.contexto(EMPRESA, USUARIO)).modulo_operativo_activo).toBe(true);
    expect((await crear({ config: null, moduloEnSuscripcion: false }).service.contexto(EMPRESA, USUARIO)).modulo_operativo_activo).toBe(false);
    expect(con.prisma.imp_config_empresa.create).not.toHaveBeenCalled();
  });

  it('T16 ronda 1: holding y reseller sin fila → operativo (el valor que usaba el guard), al leer y al crear la fila', async () => {
    for (const tipoEmpresa of ['holding', 'reseller']) {
      const { service, prisma } = crear({ config: null, moduloEnSuscripcion: false, tipoEmpresa });
      expect((await service.contexto(EMPRESA, USUARIO)).modulo_operativo_activo).toBe(true);
      expect(prisma.imp_config_empresa.create).not.toHaveBeenCalled();
      // Primera escritura: crea la fila con el mismo valor y no rechaza con MODULO_INACTIVO.
      await expect(service.assertModuloOperativoActivo(prisma, EMPRESA)).resolves.toMatchObject({ modulo_operativo_activo: true });
      expect(prisma.imp_config_empresa.create.mock.calls[0][0].data).toMatchObject({ empresa_id: EMPRESA, modulo_operativo_activo: true });
    }
  });

  it('T16: puede_configurar exige además el submódulo IMP_CONFIG (como PUT /config)', async () => {
    const r = await crear({ privilegios: ['IMP_CFG_CONFIG_EDITAR'], excluidos: ['IMP_CONFIG'] }).service.contexto(EMPRESA, USUARIO);
    expect(r.puede_configurar).toBe(false);
  });

  it('privilegiosDelUsuario: una consulta con el criterio de PermissionGuard; superadmin → TODOS', async () => {
    const { prisma } = crear({ privilegios: ['IMP_EMB_EMBARQUE_VER', 'IMP_COS_COSTO_VER'] });
    const p = await privilegiosDelUsuario(prisma, USUARIO, 'IMPORTACIONES');
    expect(p).toEqual(new Set(['IMP_EMB_EMBARQUE_VER', 'IMP_COS_COSTO_VER']));
    expect(prisma.perfiles_privilegios.findMany.mock.calls[0][0].where).toEqual({
      active: true,
      modulos: { codigo: 'IMPORTACIONES' },
      perfiles: { usuario_perfiles: { some: { user_id: USUARIO } } },
    });
    expect(await privilegiosDelUsuario(crear({ superadmin: true }).prisma, USUARIO, 'IMPORTACIONES')).toBe('TODOS');
    expect(await privilegiosDelUsuario(prisma, undefined, 'IMPORTACIONES')).toEqual(new Set());
  });
});

describe('Importaciones · bitácora', () => {
  it('bitácora con los eventos nuevos (cierre, reapertura, sello, asiento fallido/reintentado, liberado sin inventario)', async () => {
    const at = (min: number) => new Date(Date.UTC(2026, 9, 20, 12, min));
    const bitacora = [
      { evento: 'EXPEDIENTE_CERRADO', detalle: null, usuario_id: null, created_at: at(6) },
      { evento: 'EXPEDIENTE_REABIERTO', detalle: null, usuario_id: null, created_at: at(5) },
      { evento: 'EXPEDIENTE_SELLADO', detalle: null, usuario_id: null, created_at: at(4) },
      { evento: 'ASIENTO_FALLIDO', detalle: { asiento: 'CIERRE', estado: 'PENDIENTE', codigo: 'PERIODO_CERRADO' }, usuario_id: null, created_at: at(3) },
      { evento: 'ASIENTO_REINTENTADO', detalle: { despacho_id: DESP, estado: 'GENERADO' }, usuario_id: null, created_at: at(2) },
      { evento: 'LIBERADO_SIN_INVENTARIO', detalle: null, usuario_id: null, created_at: at(1) },
      { evento: 'ESTADO_CAMBIO', estado_anterior: 'DESPACHADO', estado_nuevo: 'LIBERADO', detalle: null, usuario_id: null, created_at: at(0) },
    ];
    const { service, prisma } = crear({ bitacora });
    prisma.imp_embarques.findFirst = jest.fn().mockResolvedValue({ id: EMB, empresa_id: EMPRESA, estado: 'LIBERADO', activo: true });
    const r = await service.getBitacora(EMB, EMPRESA);
    expect(r.map((e) => [e.evento, e.resumen])).toEqual([
      ['EXPEDIENTE_CERRADO', 'Se cerró el expediente'],
      ['EXPEDIENTE_REABIERTO', 'Se reabrió el expediente'],
      ['EXPEDIENTE_SELLADO', 'Se selló el expediente'],
      ['ASIENTO_FALLIDO', 'El asiento contable del cierre quedó pendiente'],
      ['ASIENTO_REINTENTADO', 'Se reintentó el asiento contable del despacho'],
      ['LIBERADO_SIN_INVENTARIO', 'Ítems liberados sin stock: su producto no maneja inventario'],
      ['ESTADO_CAMBIO', 'Cambió el estado del embarque: Despachado → Liberado'],
    ]);
  });

  it('bitácora de un embarque de otra empresa → 404 EMBARQUE_NO_ENCONTRADO (ensureEmbarqueExists con código)', async () => {
    const { service, prisma } = crear();
    prisma.imp_embarques.findFirst = jest.fn().mockResolvedValue(null);
    expect(await cuerpo(service.getBitacora(EMB, OTRA))).toMatchObject({ status: 404, codigo: 'EMBARQUE_NO_ENCONTRADO' });
  });
});

describe('Importaciones · estadoAsientoVigente (F5 + F1)', () => {
  const g = (estado: string | null, codigo: string | null = null, mensaje: string | null = null) => ({ estado, codigo, mensaje });
  it('documento CONFIRMADO → GENERADO con su número, diga lo que diga la columna', () => {
    expect(estadoAsientoVigente(g('PENDIENTE', 'MAPEO_FALTANTE'), { id: 'd', numero: 12 }, 'despacho')).toEqual({ estado: 'GENERADO', documento_id: 'd', numero: '12' });
    expect(estadoAsientoVigente(g(null), { id: 'd', numero: null }, 'cierre')).toEqual({ estado: 'GENERADO', documento_id: 'd', numero: null });
  });
  it('columna GENERADO sin documento CONFIRMADO → PENDIENTE/ASIENTO_REVERTIDO', () => {
    expect(estadoAsientoVigente(g('GENERADO'), null, 'cierre')).toEqual({
      estado: 'PENDIENTE',
      codigo: 'ASIENTO_REVERTIDO',
      mensaje: 'El asiento de cierre se revirtió y no tiene reemplazo: reintentalo.',
    });
  });
  it('F1: GENERADO con CORRECCION_MANUAL sigue GENERADO aunque el documento esté REVERTIDO', () => {
    expect(estadoAsientoVigente(g('GENERADO', 'CORRECCION_MANUAL', 'Corregido a mano con el asiento N° 231.'), null, 'despacho')).toEqual({
      estado: 'GENERADO',
      codigo: 'CORRECCION_MANUAL',
      mensaje: 'Corregido a mano con el asiento N° 231.',
    });
  });
  it('si no, vale la columna; sin dato, null', () => {
    expect(estadoAsientoVigente(g('PENDIENTE', 'PERIODO_CERRADO', 'Período cerrado'), null, 'despacho')).toEqual({
      estado: 'PENDIENTE',
      codigo: 'PERIODO_CERRADO',
      mensaje: 'Período cerrado',
    });
    expect(estadoAsientoVigente(g('NO_APLICA'), null, 'despacho')).toEqual({ estado: 'NO_APLICA' });
    expect(estadoAsientoVigente(g(null), null, 'despacho')).toBeNull();
  });
  it('la regla en SQL: EXISTS del CONFIRMADO, GENERADO sin CORRECCION_MANUAL → PENDIENTE, despacho y cierre', () => {
    const sql = sqlEmbarquesConAsientoPendiente(EMPRESA);
    expect(sql.values).toEqual(expect.arrayContaining([EMPRESA, 'CORRECCION_MANUAL']));
    const texto = sql.sql.replace(/\s+/g, ' ');
    expect(texto).toContain("cd.origen_tipo = 'imp_despacho' AND cd.origen_id = d.id AND cd.estado = 'CONFIRMADO'");
    expect(texto).toContain("cd.origen_tipo = 'imp_cierre' AND cd.origen_id = e.id AND cd.estado = 'CONFIRMADO'");
    expect(texto).toContain("WHEN d.asiento_estado = 'GENERADO' AND d.asiento_codigo IS DISTINCT FROM");
    expect(texto).toContain("WHEN e.asiento_cierre_estado = 'GENERADO' AND e.asiento_cierre_codigo IS DISTINCT FROM");
  });
});

describe('Importaciones · generarCxP sobre un embarque eliminado (pendiente de T14)', () => {
  const armar = (embarque: Record<string, any> | null) => {
    const tx: any = {
      $executeRaw: jest.fn().mockResolvedValue(1),
      imp_config_empresa: { findUnique: jest.fn().mockResolvedValue({ empresa_id: EMPRESA, modulo_operativo_activo: true, perfil_activo: 'AUTOS' }) },
      imp_embarques: { findFirst: jest.fn(({ where }: any) => Promise.resolve(embarque && where.activo === true && !embarque.activo ? null : embarque)) },
      imp_componentes_costo: {
        findFirst: jest
          .fn()
          .mockResolvedValue({
            id: 'c-1',
            embarque_id: EMB,
            empresa_id: EMPRESA,
            proveedor_id: 'p-1',
            importe: 1000,
            cotizacion: 1,
            moneda_id: 'mon-pyg',
            importe_gs: 1000,
            compra_id: null,
            gasto_id: null,
            cuenta_pagar_id: null,
          }),
        update: jest.fn(),
      },
      proveedores: { findFirst: jest.fn().mockResolvedValue({ id: 'p-1' }) },
      empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: 'mon-pyg' }) },
      imp_embarques_bitacora: { create: jest.fn() },
    };
    const prisma: any = { $transaction: jest.fn((cb: any) => cb(tx)) };
    const importaciones = new ImportacionesService(prisma, {} as any, {} as any, {} as any, {} as any, {} as any, {} as any);
    const compras: any = {
      buildCuotasPersist: jest.fn(() => [{ numero_cuota: 1 }]),
      resolvePlazoCreditoDias: jest.fn(() => 0),
      persistCuentasPagar: jest.fn().mockResolvedValue([{ id: 'cxp-nueva' }]),
    };
    return { cxp: new ImportacionesCxPService(prisma, compras, importaciones), compras };
  };
  const dto: any = { fecha_emision: '2026-10-20', plazo_credito_dias: 0 };

  it('embarque inactivo → 404 EMBARQUE_NO_ENCONTRADO', async () => {
    const { cxp, compras } = armar({ id: EMB, empresa_id: EMPRESA, estado: 'BORRADOR', activo: false });
    expect(await cuerpo(cxp.generarCxP(EMB, 'c-1', dto, EMPRESA, USUARIO))).toMatchObject({ status: 404, codigo: 'EMBARQUE_NO_ENCONTRADO' });
    expect(compras.persistCuentasPagar).not.toHaveBeenCalled();
  });

  it.each(['CERRADO', 'SELLADO'])('en %s se permite (pagar un costo existente)', async (estado) => {
    const { cxp, compras } = armar({ id: EMB, empresa_id: EMPRESA, estado, activo: true });
    await expect(cxp.generarCxP(EMB, 'c-1', dto, EMPRESA, USUARIO)).resolves.toMatchObject({ cuenta_pagar_principal_id: 'cxp-nueva' });
    expect(compras.persistCuentasPagar).toHaveBeenCalledTimes(1);
  });
});
