import { readFileSync } from 'fs';
import { join } from 'path';
import { ExecutionContext, ForbiddenException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { BloqueosDePlan, SIN_BLOQUEOS_DE_PLAN } from 'src/auth/guards/acceso-por-plan';
import { REQUIRE_PERMISSION_KEY } from 'src/auth/decorators/require-permission.decorator';
import { REQUIRE_SUBMODULO_KEY } from 'src/auth/decorators/require-submodulo.decorator';
import { ModuleGuard } from 'src/auth/guards/module.guard';
import { SubmoduloGuard } from 'src/auth/guards/submodulo.guard';
import { SEGURIDAD_SEED } from 'src/seguridad/seeds/seguridad.seed-data';
import { ComprasService } from 'src/compras/compras.service';
import { agruparHaberDespacho, CODIGOS_TRIBUTO, ComponenteAsiento, repartirIva } from './asiento-despacho';
import { IMP_ESTADOS_EMBARQUE } from './dto/importaciones.dto';
import { CODIGOS_IMP, HTTP_DE_CODIGO } from './errores-imp';
import { asientoResuelto } from './estado-asiento';
import { AccionEmbarque, accionesPermitidas, EstadoAcciones, SUBMODULO_DE_ACCION } from './estados-embarque';
import { ImportacionesController } from './importaciones.controller';
import { reglaAltaCosto, reglaCabecera, reglaCosto, reglaEliminarEmbarque, reglaItem } from './reglas-edicion';
import { armarVistaLiberacion } from './vista-liberacion';

/**
 * Importaciones según la configuración (plan Task 24; spec «Probar según configuración»): una fila por combinación de la matriz (1–25), los
 * perfiles del spec, la concurrencia y los ciclos.
 *
 * - Las filas 1 y 25 corren los guards reales (`ModuleGuard`, `SubmoduloGuard`) con el `Reflector` de Nest sobre los handlers del controller.
 * - Las demás se prueban sobre las piezas puras que deciden (las mismas que usan el servicio y la pantalla): `accionesPermitidas`,
 *   `reglas-edicion`, `agruparHaberDespacho`/`repartirIva`, `armarVistaLiberacion`, la tabla de códigos.
 * - Lo que necesita el servicio entero (dos transacciones con el mutex de `imp:`, asientos, Facturas y Gastos) ya tiene su prueba en el spec de
 *   cada tarea: acá se indexa por fila y se verifica que esa prueba siga existiendo (si alguien la borra, la matriz falla y dice cuál).
 */

// ── Apoyo ────────────────────────────────────────────────────────────────────

const TODOS = new Set([
  'IMP_EMB_EMBARQUE_VER',
  'IMP_EMB_EMBARQUE_CREAR',
  'IMP_EMB_EMBARQUE_EDITAR',
  'IMP_EMB_EMBARQUE_ELIMINAR',
  'IMP_EMB_EMBARQUE_CERRAR',
  'IMP_COS_COSTO_VER',
  'IMP_COS_COSTO_CREAR',
  'IMP_COS_COSTO_EDITAR',
  'IMP_DES_DESPACHO_VER',
  'IMP_DES_DESPACHO_CREAR',
  'IMP_DES_DESPACHO_EDITAR',
  'IMP_DES_DESPACHO_ELIMINAR',
  'IMP_DES_DESPACHO_PROCESAR',
  'IMP_CFG_CONFIG_VER',
  'IMP_CFG_CONFIG_EDITAR',
]);

const estado = (parcial: Partial<EstadoAcciones> = {}): EstadoAcciones => ({
  estado: 'BORRADOR',
  modulo_operativo_activo: true,
  tiene_contabilidad: true,
  despacho: null,
  asiento_cierre_estado: null,
  perfil_distinto: false,
  ...parcial,
});
const DESPACHO_OK = { estado: 'CONFIRMADO', asiento_estado: 'GENERADO' };
const acciones = (e: Partial<EstadoAcciones>, permisos: Set<string> | 'TODOS' = TODOS, plan: BloqueosDePlan = SIN_BLOQUEOS_DE_PLAN) => accionesPermitidas(estado(e), permisos, plan);
const accion = (e: Partial<EstadoAcciones>, a: AccionEmbarque, permisos?: Set<string> | 'TODOS', plan?: BloqueosDePlan) => acciones(e, permisos, plan).find((x) => x.accion === a);
const ESCRITURAS_POR_ESTADO = IMP_ESTADOS_EMBARQUE.map((e) => [e] as const);

const comp = (id: string, linea: number, concepto_codigo: string, proveedor_id: string | null, importe_gs: number): ComponenteAsiento => ({ id, linea, concepto_codigo, proveedor_id, importe_gs });
const CTX_HABER = { proveedorEmbarqueId: 'prov-exterior', despachanteId: null as string | null, hayAnticipoDespacho: false, hayCuentaPuente: false };

const lineaVista = (parcial: Record<string, unknown> = {}) => ({
  id: 'i1',
  linea: 1,
  producto: { id: 'p1', codigo: 'P-1', descripcion: 'Producto' },
  chasis: null,
  cantidad: 10,
  costo_unitario_gs: 1500,
  maneja_inventario: true,
  maneja_lote: false,
  producto_existente_por_chasis: false,
  ...parcial,
});

/** Un contexto de ejecución sobre un handler real del controller, como lo arma Nest. */
const contextoHandler = (handler: keyof ImportacionesController, metodo = 'GET'): ExecutionContext =>
  ({
    getHandler: () => ImportacionesController.prototype[handler] as unknown as () => void,
    getClass: () => ImportacionesController,
    switchToHttp: () => ({ getRequest: () => ({ user: { id: 'u-1', empresa_id: 'emp-1' }, method: metodo, url: `/importaciones/${String(handler)}` }) }),
  }) as unknown as ExecutionContext;

/** Prisma de mentira para los guards: empresa común, sin superadmin; `modulos` y `excluidos` dicen qué tiene el plan. */
function prismaPlan({ modulos = ['IMPORTACIONES'], excluidos = [] as string[] } = {}) {
  return {
    usuario: { findUnique: jest.fn(() => Promise.resolve({ is_superadmin: false, username: 'qa' })) },
    empresas: { findUnique: jest.fn(() => Promise.resolve({ type: 'subsidiary' })) },
    suscripcion_modulos: {
      findFirst: jest.fn(({ where }: any) => {
        const codigo = where?.modulos?.codigo;
        if (codigo) return Promise.resolve(modulos.includes(codigo) ? { id: `sm-${codigo}` } : null);
        return Promise.resolve(modulos.includes('IMPORTACIONES') ? { id: 'sm-imp' } : null);
      }),
    },
    suscripciones: { findFirst: jest.fn(() => Promise.resolve({ id: 'sus-1' })) },
    submodulos: { findFirst: jest.fn(({ where }: any) => Promise.resolve({ id: `sub-${where.codigo}`, modulo_id: 'mod-imp', es_addon: false })) },
    suscripcion_submodulos: {
      findFirst: jest.fn(({ where }: any) =>
        Promise.resolve(where.active === false && excluidos.includes(String(where.submodulo_id).replace('sub-', '')) ? { id: 'excl' } : null),
      ),
    },
  } as any;
}

const reflector = new Reflector();
const pasaModulo = (handler: keyof ImportacionesController, plan = prismaPlan()) => new ModuleGuard(reflector, plan).canActivate(contextoHandler(handler));
const pasaSubmodulo = (handler: keyof ImportacionesController, plan = prismaPlan(), metodo = 'GET') => new SubmoduloGuard(reflector, plan).canActivate(contextoHandler(handler, metodo));

/** Las pruebas de servicio que cubren una fila: archivo (relativo a src/) y el comienzo del título. */
type Cobertura = Array<[archivo: string, titulo: string]>;
const SRC = join(__dirname, '..');
const textoDe = new Map<string, string>();
const leer = (archivo: string) => {
  if (!textoDe.has(archivo)) textoDe.set(archivo, readFileSync(join(SRC, archivo), 'utf8'));
  return textoDe.get(archivo) ?? '';
};
const pruebaExiste = (archivo: string, titulo: string) => leer(archivo).includes(titulo);

// ── Matriz (spec: «Probar según configuración», filas 1–25) ──────────────────

describe('Importaciones según la configuración: la matriz', () => {
  describe('fila 1 · módulo IMPORTACIONES fuera de la suscripción', () => {
    it.each([['findAll'], ['findOne'], ['contexto'], ['getConceptos'], ['liberarEmbarque'], ['confirmarDespacho']] as const)('ModuleGuard corta %s con 403', async (handler) => {
      await expect(pasaModulo(handler, prismaPlan({ modulos: [] }))).rejects.toBeInstanceOf(ForbiddenException);
    });
    it('con el módulo en la suscripción, pasa (y la clase lo pide para todos los handlers)', async () => {
      await expect(pasaModulo('findAll')).resolves.toBe(true);
    });
  });

  describe('fila 2 · real de DOBA: suscripción + operativo + CONSUMO_MASIVO + Contabilidad', () => {
    it('el circuito completo ofrece en cada estado su acción principal, permitida con todos los permisos', () => {
      const principal: Array<[string, AccionEmbarque, Partial<EstadoAcciones>]> = [
        ['BORRADOR', 'marcar_en_transito', {}],
        ['EN_TRANSITO', 'marcar_arribado', {}],
        ['ARRIBADO', 'cargar_despacho', {}],
        ['EN_DESPACHO', 'confirmar_despacho', { despacho: { estado: 'BORRADOR', asiento_estado: null } }],
        ['DESPACHADO', 'liberar', { despacho: DESPACHO_OK }],
        ['LIBERADO', 'cerrar', { despacho: DESPACHO_OK }],
        ['CERRADO', 'sellar', { despacho: DESPACHO_OK, asiento_cierre_estado: 'GENERADO' }],
      ];
      for (const [e, a, extra] of principal) expect(accion({ estado: e, ...extra }, a)).toEqual({ accion: a, permitida: true });
      // EN_DESPACHO sin despacho (DOBA tuvo idas y vueltas a EN_DESPACHO): se carga el despacho desde ahí (P2).
      expect(accion({ estado: 'EN_DESPACHO', despacho: null }, 'cargar_despacho')).toEqual({ accion: 'cargar_despacho', permitida: true });
      // Revertir y volver a liberar; reabrir y volver a cerrar.
      expect(accion({ estado: 'LIBERADO', despacho: DESPACHO_OK }, 'revertir_liberacion')).toMatchObject({ permitida: true });
      expect(accion({ estado: 'CERRADO', despacho: DESPACHO_OK, asiento_cierre_estado: 'GENERADO' }, 'reabrir')).toMatchObject({ permitida: true });
    });
    it('IMP-2026-000001 (F1: GENERADO/CORRECCION_MANUAL, asiento N° 231) cuenta como resuelto: liberar no lo bloquea y no se ofrece reintentar', () => {
      expect(asientoResuelto('GENERADO')).toBe(true);
      const liberado = acciones({ estado: 'LIBERADO', despacho: { estado: 'CONFIRMADO', asiento_estado: 'GENERADO' } });
      expect(liberado.find((a) => a.accion === 'reintentar_asiento_despacho')).toBeUndefined();
    });
  });

  describe('fila 3 · modulo_operativo_activo = false con embarques abiertos', () => {
    it.each(ESCRITURAS_POR_ESTADO)('%s: toda acción de escritura viene MODULO_INACTIVO; los reintentos de asiento siguen', (e) => {
      const lista = acciones({ estado: e, modulo_operativo_activo: false, despacho: { estado: 'CONFIRMADO', asiento_estado: 'PENDIENTE' }, asiento_cierre_estado: 'PENDIENTE' });
      for (const a of lista) {
        if (a.accion.startsWith('reintentar_asiento')) expect(a).toEqual({ accion: a.accion, permitida: true });
        else expect(a).toMatchObject({ permitida: false, codigo: 'MODULO_INACTIVO' });
      }
    });
    it('MODULO_INACTIVO es 400', () => expect(HTTP_DE_CODIGO.MODULO_INACTIVO).toBe(400));
  });

  describe('fila 4 · perfil AUTOS', () => {
    it('liberar crea un producto por chasis o usa el existente; un ítem sin chasis bloquea con ITEM_SIN_CHASIS y su línea', () => {
      const v = armarVistaLiberacion({
        perfil: 'AUTOS',
        deposito: { id: 'd1', descripcion: 'Central', usa_lotes: false },
        items: [
          lineaVista({ chasis: 'KMHD00010A', producto: null, cantidad: 1 }),
          lineaVista({ id: 'i2', linea: 2, chasis: 'KMHD00011A', producto: null, cantidad: 1, producto_existente_por_chasis: true }),
          lineaVista({ id: 'i3', linea: 3, chasis: null, producto: null, cantidad: 1 }),
        ] as never,
      });
      expect(v.lineas.map((l) => l.efecto)).toEqual(['CREA_PRODUCTO', 'USA_PRODUCTO_EXISTENTE', 'CREA_PRODUCTO']);
      expect(v.errores).toEqual([expect.objectContaining({ codigo: 'ITEM_SIN_CHASIS', linea: 3 })]);
    });
    it('VIN_INVALIDO es 400 y CHASIS_DUPLICADO 409', () => {
      expect(HTTP_DE_CODIGO.VIN_INVALIDO).toBe(400);
      expect(HTTP_DE_CODIGO.CHASIS_DUPLICADO).toBe(409);
    });
  });

  describe('fila 5 · embarque con perfil distinto del activo (Agogó)', () => {
    it('la cabecera no se edita (PERFIL_DISTINTO); el resto de las acciones opera', () => {
      const lista = acciones({ estado: 'LIBERADO', perfil_distinto: true, despacho: DESPACHO_OK });
      expect(lista.find((a) => a.accion === 'editar')).toMatchObject({ permitida: false, codigo: 'PERFIL_DISTINTO' });
      expect(lista.filter((a) => a.accion !== 'editar' && a.accion !== 'eliminar').every((a) => a.permitida)).toBe(true);
    });
    it('cambiar el perfil activo con embarques abiertos → PERFIL_CON_EMBARQUES_ACTIVOS (409)', () => {
      expect(HTTP_DE_CODIGO.PERFIL_CON_EMBARQUES_ACTIVOS).toBe(409);
    });
  });

  describe('fila 6 · criterio_cotizacion FACTURA / DESPACHO / CIERRE_EMBARQUE', () => {
    // Facturas lo aplica como hoy (`compras.service.ts` resolverCotizacionImportacion, regresión): sin la cotización elegida, la de la factura.
    const resolver = (criterio: string | null, despacho: number | null, cierre: number | null, factura = 7300) => {
      const tx = {
        imp_config_empresa: { findUnique: jest.fn(() => Promise.resolve(criterio ? { criterio_cotizacion: criterio } : null)) },
        imp_despachos: { findFirst: jest.fn(() => Promise.resolve({ cotizacion_usada: despacho })) },
        imp_embarques: { findFirst: jest.fn(() => Promise.resolve({ cotizacion_cierre: cierre })) },
      };
      return (ComprasService.prototype as any).resolverCotizacionImportacion.call({}, tx, 'emp-1', 'emb-1', factura) as Promise<number>;
    };
    it.each([
      ['FACTURA', 7400, 7500, 7300],
      [null, 7400, 7500, 7300],
      ['DESPACHO', 7400, 7500, 7400],
      ['DESPACHO', null, 7500, 7300],
      ['CIERRE_EMBARQUE', 7400, 7500, 7500],
      ['CIERRE_EMBARQUE', 7400, null, 7300],
    ])('criterio %s (despacho %s, cierre %s) → %d', async (criterio, despacho, cierre, esperado) => {
      await expect(resolver(criterio, despacho, cierre)).resolves.toBe(esperado);
    });
  });

  describe('fila 7 · sin módulo Contabilidad', () => {
    it('sin aviso ni reintento: liberar no exige asiento, sellar tampoco y no se ofrece reintentar', () => {
      const sinCont = { tiene_contabilidad: false };
      expect(accion({ ...sinCont, estado: 'DESPACHADO', despacho: { estado: 'CONFIRMADO', asiento_estado: 'NO_APLICA' } }, 'liberar')).toMatchObject({ permitida: true });
      expect(accion({ ...sinCont, estado: 'DESPACHADO', despacho: { estado: 'CONFIRMADO', asiento_estado: null } }, 'liberar')).toMatchObject({ permitida: true });
      expect(accion({ ...sinCont, estado: 'CERRADO', despacho: DESPACHO_OK, asiento_cierre_estado: null }, 'sellar')).toMatchObject({ permitida: true });
      const cerrado = acciones({ ...sinCont, estado: 'CERRADO', despacho: { estado: 'CONFIRMADO', asiento_estado: null }, asiento_cierre_estado: null });
      expect(cerrado.some((a) => a.accion.startsWith('reintentar_asiento'))).toBe(false);
    });
  });

  describe('fila 8 · Contabilidad sin IMPORTACIONES_EN_CURSO (sin cuenta puente)', () => {
    it('el haber va por proveedor; sin puente los tributos no van al anticipo de despacho (van al despachante)', () => {
      const r = agruparHaberDespacho([comp('c1', 1, 'FOB', null, 1000), comp('c2', 2, 'IMP_ARANCEL', null, 300)], { ...CTX_HABER, despachanteId: 'desp-1', hayAnticipoDespacho: true, hayCuentaPuente: false });
      expect(r.haber).toEqual([
        { tipo: 'PROVEEDOR', proveedor_id: 'prov-exterior', monto: 1000, componentes: ['c1'] },
        { tipo: 'DESPACHANTE', proveedor_id: 'desp-1', monto: 300 },
      ]);
    });
    it('sin asiento de cierre (NO_APLICA) sellar no lo exige', () => {
      expect(accion({ estado: 'CERRADO', despacho: DESPACHO_OK, asiento_cierre_estado: 'NO_APLICA' }, 'sellar')).toMatchObject({ permitida: true });
    });
  });

  describe('fila 9 · con IMPORTACIONES_EN_CURSO y anticipo de despacho', () => {
    it('tributos contra ANTICIPO_DESPACHO; los costos manuales contra su proveedor', () => {
      const r = agruparHaberDespacho(
        [comp('c1', 1, 'FLETE_MARITIMO', 'prov-flete', 500), comp('c2', 2, 'IMP_ARANCEL', null, 300), comp('c3', 3, 'IMP_IVA_IMPORTACION', null, 200)],
        { ...CTX_HABER, hayAnticipoDespacho: true, hayCuentaPuente: true, despachanteId: 'desp-1' },
      );
      expect(r.errores).toEqual([]);
      expect(r.haber).toEqual([
        { tipo: 'PROVEEDOR', proveedor_id: 'prov-flete', monto: 500, componentes: ['c1'] },
        { tipo: 'ANTICIPO_DESPACHO', monto: 500 },
      ]);
    });
  });

  describe('fila 10 · con puente y sin anticipo: con despachante / sin despachante', () => {
    it('con despachante, los tributos contra su pasivo; sin despachante, TRIBUTOS_SIN_CONTRAPARTIDA y no hay línea parcial', () => {
      const tributos = [comp('c1', 1, 'IMP_ARANCEL', null, 300)];
      expect(agruparHaberDespacho(tributos, { ...CTX_HABER, hayCuentaPuente: true, despachanteId: 'desp-1' }).haber).toEqual([{ tipo: 'DESPACHANTE', proveedor_id: 'desp-1', monto: 300 }]);
      const sin = agruparHaberDespacho(tributos, { ...CTX_HABER, hayCuentaPuente: true });
      expect(sin).toEqual({ haber: [], errores: [{ codigo: 'TRIBUTOS_SIN_CONTRAPARTIDA' }] });
    });
  });

  describe('fila 11 · mapeo faltante', () => {
    it('con el asiento del despacho PENDIENTE: liberar bloqueado con ASIENTO_DESPACHO_PENDIENTE y Reintentar ofrecido', () => {
      const e = { estado: 'DESPACHADO', despacho: { estado: 'CONFIRMADO', asiento_estado: 'PENDIENTE' } };
      expect(accion(e, 'liberar')).toMatchObject({ permitida: false, codigo: 'ASIENTO_DESPACHO_PENDIENTE' });
      expect(accion(e, 'reintentar_asiento_despacho')).toEqual({ accion: 'reintentar_asiento_despacho', permitida: true });
    });
    it('después de mapear y reintentar (GENERADO), libera', () => {
      expect(accion({ estado: 'DESPACHADO', despacho: DESPACHO_OK }, 'liberar')).toEqual({ accion: 'liberar', permitida: true });
    });
  });

  describe('fila 12 · período contable cerrado en la fecha del despacho / del cierre', () => {
    it('el cierre con el asiento PENDIENTE (PERIODO_CERRADO) no se sella y ofrece reintentar', () => {
      const e = { estado: 'CERRADO', despacho: DESPACHO_OK, asiento_cierre_estado: 'PENDIENTE' };
      expect(accion(e, 'sellar')).toMatchObject({ permitida: false, codigo: 'ASIENTO_CIERRE_PENDIENTE' });
      expect(accion(e, 'reintentar_asiento_cierre')).toMatchObject({ permitida: true });
    });
  });

  describe('fila 13 · asiento REVERTIDO (caso DOBA)', () => {
    it('REVERTIDO sin reemplazo cuenta como pendiente (se reintenta); con uno CONFIRMADO, ASIENTO_YA_GENERADO es 409', () => {
      expect(asientoResuelto('PENDIENTE')).toBe(false);
      expect(HTTP_DE_CODIGO.ASIENTO_YA_GENERADO).toBe(409);
    });
  });

  describe('fila 14 · IVA del despacho con parte al 5 % / solo 10 % / parte al 5 % mayor al total', () => {
    it.each([
      [100, 30, { iva10: 70, iva5: 30 }],
      [100, 0, { iva10: 100, iva5: 0 }],
      [100, 100, { iva10: 0, iva5: 100 }],
    ])('IVA %d con %d al 5 % → %o', (total, parte5, esperado) => expect(repartirIva(total, parte5)).toEqual(esperado));
    it('la parte al 5 % mayor al total → IVA_5_SUPERA_TOTAL con campo', () => {
      expect(() => repartirIva(100, 101)).toThrow(expect.objectContaining({ response: expect.objectContaining({ codigo: 'IVA_5_SUPERA_TOTAL', campo: 'iva_importacion_5_gs' }) }));
    });
  });

  describe('fila 15 · varios proveedores + FOB sin proveedor + uno manual sin proveedor', () => {
    it('una línea por proveedor, el FOB al del embarque y el manual sin proveedor bloquea con su línea', () => {
      const r = agruparHaberDespacho(
        [comp('c1', 1, 'FOB', null, 1000), comp('c2', 2, 'FLETE_MARITIMO', 'prov-flete', 200), comp('c3', 3, 'SEGURO_INTERNACIONAL', 'prov-flete', 50), comp('c4', 4, 'OTROS_GASTOS', null, 10)],
        CTX_HABER,
      );
      expect(r.haber).toEqual([
        { tipo: 'PROVEEDOR', proveedor_id: 'prov-exterior', monto: 1000, componentes: ['c1'] },
        { tipo: 'PROVEEDOR', proveedor_id: 'prov-flete', monto: 250, componentes: ['c2', 'c3'] },
      ]);
      expect(r.errores).toEqual([{ codigo: 'COMPONENTE_SIN_PROVEEDOR', linea: 4, componente_id: 'c4' }]);
    });
  });

  describe('fila 16 · proveedor EXTERIOR / LOCAL / ACREEDOR_VARIO', () => {
    it('el acreedor vario se rechaza con su código (400) en cabecera, costo, despacho y CxP', () => {
      expect(CODIGOS_IMP.PROVEEDOR_ACREEDOR_VARIO).toBe('PROVEEDOR_ACREEDOR_VARIO');
      expect(HTTP_DE_CODIGO.PROVEEDOR_ACREEDOR_VARIO).toBe(400);
    });
  });

  describe('fila 17 · concepto afecta_costo true / false', () => {
    it('el IVA de importación es un tributo (nunca de un proveedor) y su concepto está en la lista única de tributos (F21)', () => {
      expect(CODIGOS_TRIBUTO).toEqual(['IMP_ARANCEL', 'IMP_IVA_IMPORTACION', 'IMP_ISC', 'IMP_INC', 'IMP_ANTICIPO_IRE', 'IMP_TASA_ANA', 'IMP_OTROS_TRIBUTOS']);
    });
  });

  describe('fila 18 · conceptos por perfil, de sistema / propio, activo / inactivo', () => {
    it('editar uno de sistema → CONCEPTO_DE_SISTEMA (409)', () => expect(HTTP_DE_CODIGO.CONCEPTO_DE_SISTEMA).toBe(409));
  });

  describe('fila 19 · tasas ISC de sistema / empresa, vigentes / vencidas, superpuestas', () => {
    it('superposición y vigencia rechazadas con su código; las de sistema no se editan', () => {
      expect(HTTP_DE_CODIGO.RANGO_ISC_SUPERPUESTO).toBe(409);
      expect(HTTP_DE_CODIGO.VIGENCIA_INVALIDA).toBe(400);
      expect(HTTP_DE_CODIGO.TASA_DE_SISTEMA).toBe(409);
    });
  });

  describe('fila 20 · sucursal con lotes × producto con maneja_lote', () => {
    it('pide lote solo con las dos mitades (F25); revertir con unidades vendidas → LOTE_NO_INTEGRO / REVERSION_CON_SALIDAS (409)', () => {
      const con = armarVistaLiberacion({ perfil: 'CONSUMO_MASIVO', deposito: { id: 'd', descripcion: 'L', usa_lotes: true }, items: [lineaVista({ maneja_lote: true })] as never });
      const sin = armarVistaLiberacion({ perfil: 'CONSUMO_MASIVO', deposito: { id: 'd', descripcion: 'C', usa_lotes: false }, items: [lineaVista({ maneja_lote: true })] as never });
      expect(con.lineas[0]).toMatchObject({ pide_lote: true, efecto: 'CREA_LOTE' });
      expect(sin.lineas[0]).toMatchObject({ pide_lote: false, efecto: 'ENTRA_STOCK' });
      expect(HTTP_DE_CODIGO.LOTE_NO_INTEGRO).toBe(409);
      expect(accion({ estado: 'LIBERADO', despacho: DESPACHO_OK, hay_salidas_posteriores: true }, 'revertir_liberacion')).toMatchObject({ permitida: false, codigo: 'REVERSION_CON_SALIDAS' });
    });
  });

  describe('fila 21 · producto sin maneja_inventario', () => {
    it('la vista previa lo marca SIN_INVENTARIO y no bloquea', () => {
      const v = armarVistaLiberacion({ perfil: 'CONSUMO_MASIVO', deposito: null, items: [lineaVista({ maneja_inventario: false })] as never });
      expect(v.errores).toEqual([]);
      expect(v.lineas[0].efecto).toBe('SIN_INVENTARIO');
    });
  });

  describe('fila 22 · usuario con alcance de sucursal restringido', () => {
    it('un depósito fuera del alcance → DEPOSITO_FUERA_DE_ALCANCE (400)', () => expect(HTTP_DE_CODIGO.DEPOSITO_FUERA_DE_ALCANCE).toBe(400));
  });

  describe('filas 23 y 24 · embarque en moneda extranjera / en la moneda base', () => {
    it('sin cotización válida en moneda extranjera → COTIZACION_REQUERIDA (400); en la base no se pide (lo prueban costo, CxP y revisión)', () => {
      expect(HTTP_DE_CODIGO.COTIZACION_REQUERIDA).toBe(400);
    });
  });

  describe('fila 25 · submódulo IMP_* excluido en el plan', () => {
    it.each([
      ['IMP_DESPACHOS', 'getDespacho'],
      ['IMP_DESPACHOS', 'confirmarDespacho'],
      ['IMP_COSTOS', 'addCosto'],
      ['IMP_CONFIG', 'listIsc'],
      ['IMP_EMBARQUES', 'liberarEmbarque'],
    ] as const)('con %s excluido, SubmoduloGuard corta %s con 403', async (sub, handler) => {
      await expect(pasaSubmodulo(handler, prismaPlan({ excluidos: [sub] }))).rejects.toBeInstanceOf(ForbiddenException);
    });
    it('con IMP_DESPACHOS excluido, Facturas y Gastos siguen leyendo abiertos (IMP_EMBARQUES) y conceptos (IMP_COSTOS)', async () => {
      const plan = prismaPlan({ excluidos: ['IMP_DESPACHOS', 'IMP_CONFIG'] });
      await expect(pasaSubmodulo('findAll', plan)).resolves.toBe(true);
      await expect(pasaSubmodulo('getConceptos', plan)).resolves.toBe(true);
    });
    it('en el detalle, la acción del submódulo excluido viene SUBMODULO_NO_DISPONIBLE con el mensaje del guard', () => {
      const plan: BloqueosDePlan = { submodulos: new Map([['IMP_DESPACHOS', 'El submódulo "IMP_DESPACHOS" está deshabilitado para esta empresa']]), privilegios: new Map() };
      const lista = acciones({ estado: 'EN_DESPACHO', despacho: { estado: 'BORRADOR', asiento_estado: null } }, TODOS, plan);
      for (const a of lista) {
        if (SUBMODULO_DE_ACCION[a.accion] === 'IMP_DESPACHOS') expect(a).toMatchObject({ permitida: false, codigo: 'SUBMODULO_NO_DISPONIBLE' });
        else expect(a.permitida).toBe(true);
      }
    });
  });

  // Filas que dependen del servicio entero: su prueba vive en el spec de su tarea.
  const COBERTURA_FILAS: Record<string, Cobertura> = {
    '2 (circuito y prueba real)': [
      ['importaciones/importaciones-cierre.spec.ts', 'reabrir revierte el asiento en la misma tx y al volver a cerrar se genera otro'],
      ['importaciones/importaciones-asientos.spec.ts', 'con corrección manual del revertido (caso DOBA)'],
    ],
    '3 (servicio)': [['importaciones/importaciones-despacho.spec.ts', 'módulo apagado → MODULO_INACTIVO al editar y al eliminar']],
    '4 (servicio)': [
      ['importaciones/importaciones-items-costos.spec.ts', 'VIN de 16 caracteres → VIN_INVALIDO'],
      ['importaciones/importaciones-liberacion.spec.ts', 'chasis de un producto existente lo usa (no crea otro)'],
    ],
    '9 (asiento de cierre y reapertura)': [['importaciones/importaciones-cierre.spec.ts', 'reabrir revierte el asiento en la misma tx']],
    '13 (reintento)': [['importaciones/importaciones-asientos.spec.ts', 'reintento con documento REVERTIDO lo desvincula y genera otro']],
    '14 (servicio)': [['importaciones/importaciones-asientos.spec.ts', 'IVA 30 de 100 al 5 %: dos líneas; solo 10 %: una']],
    '20 (servicio)': [['importaciones/importaciones-liberacion.spec.ts', 'revertir con unidades vendidas → REVERSION_CON_SALIDAS']],
    '23 (CxP en USD)': [['importaciones/importaciones-items-costos.spec.ts', 'CxP de un costo USD de un embarque PYG sale en USD con su cotización']],
  };
  it.each(Object.entries(COBERTURA_FILAS))('fila %s: su prueba de servicio sigue existiendo', (_fila, cobertura) => {
    for (const [archivo, titulo] of cobertura) expect({ archivo, titulo, existe: pruebaExiste(archivo, titulo) }).toEqual({ archivo, titulo, existe: true });
  });
});

// ── Perfiles (spec «Perfiles») ───────────────────────────────────────────────

describe('Importaciones según la configuración: los perfiles', () => {
  const de = (...p: string[]) => new Set(p);
  const permitidas = (e: Partial<EstadoAcciones>, permisos: Set<string>) =>
    acciones(e, permisos)
      .filter((a) => a.permitida)
      .map((a) => a.accion)
      .sort();
  const EN_DESPACHO = { estado: 'EN_DESPACHO', despacho: { estado: 'BORRADOR', asiento_estado: null } };
  const DESPACHADO = { estado: 'DESPACHADO', despacho: DESPACHO_OK };

  it('solo _VER (Supervisor): ninguna acción habilitada en ningún estado, cada una con SIN_PERMISO', () => {
    const ver = de('IMP_EMB_EMBARQUE_VER', 'IMP_COS_COSTO_VER', 'IMP_DES_DESPACHO_VER', 'IMP_CFG_CONFIG_VER');
    for (const e of IMP_ESTADOS_EMBARQUE) {
      for (const a of acciones({ estado: e, despacho: DESPACHO_OK, asiento_cierre_estado: 'PENDIENTE' }, ver)) {
        if (a.accion === 'eliminar' && ['DESPACHADO', 'LIBERADO', 'CERRADO', 'SELLADO'].includes(e)) continue; // F20: el bloqueo por datos no tapa el permiso
        expect(a).toMatchObject({ permitida: false, codigo: 'SIN_PERMISO' });
      }
    }
  });

  it('COSTO_CREAR sin _EDITAR: agrega costos (agregar_costo) y nada más', () => {
    expect(permitidas({ estado: 'BORRADOR' }, de('IMP_COS_COSTO_CREAR'))).toEqual(['agregar_costo']);
  });

  it('DESPACHO_EDITAR sin _CREAR: edita el borrador, no lo carga', () => {
    const p = de('IMP_DES_DESPACHO_EDITAR');
    expect(accion({ estado: 'ARRIBADO' }, 'cargar_despacho', p)).toMatchObject({ permitida: false, codigo: 'SIN_PERMISO' });
    expect(accion(EN_DESPACHO, 'editar_despacho', p)).toMatchObject({ permitida: true });
  });

  it('PROCESAR sin EMBARQUE_CERRAR: confirma, no libera', () => {
    const p = de('IMP_DES_DESPACHO_PROCESAR');
    expect(accion(EN_DESPACHO, 'confirmar_despacho', p)).toMatchObject({ permitida: true });
    expect(accion(DESPACHADO, 'liberar', p)).toMatchObject({ permitida: false, codigo: 'SIN_PERMISO' });
  });

  it('EMBARQUE_CERRAR sin PROCESAR: libera, revierte, cierra y sella; no confirma', () => {
    const p = de('IMP_EMB_EMBARQUE_CERRAR');
    expect(accion(EN_DESPACHO, 'confirmar_despacho', p)).toMatchObject({ permitida: false, codigo: 'SIN_PERMISO' });
    expect(accion(DESPACHADO, 'liberar', p)).toMatchObject({ permitida: true });
    expect(accion({ estado: 'LIBERADO', despacho: DESPACHO_OK }, 'revertir_liberacion', p)).toMatchObject({ permitida: true });
    expect(accion({ estado: 'CERRADO', despacho: DESPACHO_OK, asiento_cierre_estado: 'GENERADO' }, 'sellar', p)).toMatchObject({ permitida: true });
  });

  it('_EDITAR sin _ELIMINAR: edita y mueve la logística, no elimina', () => {
    const p = de('IMP_EMB_EMBARQUE_EDITAR');
    expect(permitidas({ estado: 'BORRADOR' }, p)).toEqual(['agregar_item', 'editar', 'marcar_en_transito']);
    expect(accion({ estado: 'BORRADOR' }, 'eliminar', p)).toMatchObject({ permitida: false, codigo: 'SIN_PERMISO' });
  });

  it('cada handler pide el privilegio del spec (sin COSTO_VER no hay costos ni conceptos; sin CFG_VER no hay ISC; config con IMP_CFG_CONFIG_EDITAR; ADM_IMC no existe)', () => {
    const privilegio = (h: keyof ImportacionesController) => Reflect.getMetadata(REQUIRE_PERMISSION_KEY, ImportacionesController.prototype[h])?.privilegio;
    const submodulo = (h: keyof ImportacionesController) => Reflect.getMetadata(REQUIRE_SUBMODULO_KEY, ImportacionesController.prototype[h]);
    expect([privilegio('getConceptos'), submodulo('getConceptos')]).toEqual(['IMP_COS_COSTO_VER', 'IMP_COSTOS']);
    expect([privilegio('listIsc'), submodulo('listIsc')]).toEqual(['IMP_CFG_CONFIG_VER', 'IMP_CONFIG']);
    expect([privilegio('updateConfig'), submodulo('updateConfig')]).toEqual(['IMP_CFG_CONFIG_EDITAR', 'IMP_CONFIG']);
    const todos = Object.getOwnPropertyNames(ImportacionesController.prototype).filter((h) => h !== 'constructor');
    expect(todos.map((h) => privilegio(h as keyof ImportacionesController)).filter((p) => String(p).startsWith('ADM_IMC'))).toEqual([]);
  });

  it('el seed no define ningún ADM_IMC_* y sí el submódulo ADM_IMPORTACIONES_CFG (D16)', () => {
    const submodulos = SEGURIDAD_SEED.flatMap((m) => m.submodulos);
    const codigos = submodulos.flatMap((s) => s.privilegios.map((p) => p.codigo));
    expect(codigos.filter((c) => c.startsWith('ADM_IMC_'))).toEqual([]);
    expect(submodulos.find((s) => s.codigo === 'ADM_IMPORTACIONES_CFG')).toMatchObject({ privilegios: [] });
    // La configuración de Importaciones sí la define IMP_CFG_*.
    expect(codigos).toEqual(expect.arrayContaining(['IMP_CFG_CONFIG_VER', 'IMP_CFG_CONFIG_EDITAR']));
  });
});

// ── Concurrencia y ciclos (spec) ─────────────────────────────────────────────

describe('Importaciones según la configuración: concurrencia y ciclos', () => {
  /** Las de dos transacciones corren contra el mutex real de `imp:` en el spec de su tarea; acá se indexan. */
  const CONCURRENCIA: Record<string, Cobertura> = {
    'dos liberaciones (una sola suma stock)': [['importaciones/importaciones-liberacion.spec.ts', 'dos liberaciones: la segunda relee bajo imp: y recibe ESTADO_CAMBIADO; el stock suma una vez']],
    'dos reversiones': [['importaciones/importaciones-liberacion.spec.ts', 'dos reversiones: la segunda relee bajo imp: y recibe ESTADO_CAMBIADO']],
    'dos confirmaciones': [['importaciones/importaciones-asientos.spec.ts', 'confirmar dos veces: la segunda recibe ESTADO_CAMBIADO']],
    'dos «Generar CxP»': [['importaciones/importaciones-items-costos.spec.ts', 'dos Generar CxP: la primera guarda la cuota en cuenta_pagar_id y la segunda → COSTO_CON_CXP']],
    'dos altas (números distintos)': [
      ['importaciones/services/importaciones-cabecera.spec.ts', 'el número toma imp-num: antes de leer el máximo y sale del máximo del año'],
      ['importaciones/services/importaciones-cabecera.spec.ts', 'P2002 del número → 409 NUMERO_DUPLICADO'],
    ],
    'dos reintentos de asiento': [['importaciones/importaciones-asientos.spec.ts', 'P2002 en el reintento (dos a la vez) → ASIENTO_YA_GENERADO']],
    'editar un costo contra convertirlo desde Gastos o Facturas (los dos toman imp:)': [
      ['gastos/gastos-pago-importacion.spec.ts', 'convertir un componente con CxP → COSTO_CON_CXP y no lo toca'],
      ['compras/compras-importacion-conversion.spec.ts', 'toma imp: antes de leer el embarque y el componente'],
    ],
    'reabrir contra un gasto que se imputa (CERRADO no se imputa; los dos toman imp:)': [['gastos/gastos-pago-importacion.spec.ts', 'embarque CERRADO o SELLADO: la regla de hoy (400)']],
  };
  it.each(Object.entries(CONCURRENCIA))('%s: su prueba sigue existiendo', (_caso, cobertura) => {
    for (const [archivo, titulo] of cobertura) expect({ archivo, titulo, existe: pruebaExiste(archivo, titulo) }).toEqual({ archivo, titulo, existe: true });
  });

  it('editar un costo después de que otro lo convirtió: la relectura bajo imp: lo ve con comprobante → COSTO_CON_COMPROBANTE', () => {
    const libre = { cuenta_pagar_id: null, compra_id: null, gasto_id: null, asentado: false };
    expect(reglaCosto('ARRIBADO', libre)).toEqual({ ok: true });
    expect(reglaCosto('ARRIBADO', { ...libre, gasto_id: 'gas-1' })).toMatchObject({ ok: false, codigo: 'COSTO_CON_COMPROBANTE' });
  });

  it('ciclo liberar → revertir → editar costo → liberar', () => {
    const costo = { cuenta_pagar_id: null, compra_id: null, gasto_id: null, asentado: false };
    expect(reglaCosto('LIBERADO', costo)).toMatchObject({ ok: false, codigo: 'EMBARQUE_LIBERADO' });
    expect(accion({ estado: 'LIBERADO', despacho: DESPACHO_OK }, 'revertir_liberacion')).toMatchObject({ permitida: true });
    expect(reglaCosto('DESPACHADO', costo)).toEqual({ ok: true }); // revertido: el costo (no asentado) se edita
    expect(accion({ estado: 'DESPACHADO', despacho: DESPACHO_OK }, 'liberar')).toMatchObject({ permitida: true });
  });

  it('ciclo cerrar → reabrir → costo por comprobante → cerrar', () => {
    expect(reglaAltaCosto('CERRADO', { manual: false, proveedor_id: 'p' })).toMatchObject({ ok: false, codigo: 'EMBARQUE_NO_EDITABLE' });
    expect(accion({ estado: 'CERRADO', despacho: DESPACHO_OK, asiento_cierre_estado: 'GENERADO' }, 'reabrir')).toMatchObject({ permitida: true });
    expect(reglaAltaCosto('LIBERADO', { manual: false, proveedor_id: 'p' })).toEqual({ ok: true }); // por comprobante sigue imputable
    expect(reglaAltaCosto('LIBERADO', { manual: true, proveedor_id: 'p' })).toMatchObject({ ok: false, codigo: 'EMBARQUE_LIBERADO' });
    expect(accion({ estado: 'LIBERADO', despacho: DESPACHO_OK }, 'cerrar')).toMatchObject({ permitida: true });
  });

  it('eliminar en BORRADOR y con documentos (409 con la lista)', () => {
    expect(reglaEliminarEmbarque('BORRADOR', [])).toEqual({ ok: true });
    expect(reglaEliminarEmbarque('ARRIBADO', ['CXP', 'GASTO'])).toEqual({ ok: false, codigo: 'EMBARQUE_CON_MOVIMIENTOS', movimientos: ['CXP', 'GASTO'] });
    expect(HTTP_DE_CODIGO.EMBARQUE_CON_MOVIMIENTOS).toBe(409);
  });

  it('borrar un ítem y volver a cargar su chasis: la unicidad cuenta solo ítems activos (servicio) y el ítem sin costos vinculados se borra', () => {
    expect(reglaItem('ARRIBADO', { costos_vinculados: 0 })).toEqual({ ok: true });
    expect(reglaItem('ARRIBADO', { costos_vinculados: 1 })).toMatchObject({ ok: false, codigo: 'ITEM_CON_COSTOS_VINCULADOS' });
    expect(reglaItem('DESPACHADO', { costos_vinculados: 0 })).toMatchObject({ ok: false, codigo: 'ITEMS_CERRADOS' });
    expect(pruebaExiste('importaciones/importaciones-items-costos.spec.ts', 'la unicidad cuenta solo ítems activos de embarques activos: borrar un ítem y volver a cargar su chasis pasa')).toBe(true);
  });

  it('la cabecera desde DESPACHADO solo deja los datos sin efecto (y proveedor/moneda hasta ARRIBADO)', () => {
    expect(reglaCabecera('DESPACHADO', ['notas', 'bill_of_lading'])).toEqual({ ok: true });
    expect(reglaCabecera('EN_DESPACHO', ['proveedor_id'])).toMatchObject({ ok: false, codigo: 'CAMPO_NO_EDITABLE', campo: 'proveedor_id' });
  });
});
