import { BadRequestException, NotFoundException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { readFileSync } from 'fs';
import { join } from 'path';
import { crearIntegracionMock } from 'src/contabilidad/services/__helpers__/integracion-mock';
import { conFaltaDeMapeoComoError } from 'src/contabilidad-conciliacion/integrador-sombra';
import { FaltaMapeoError } from 'src/contabilidad/services/falta-mapeo.error';
import { CONCEPTO_TRIBUTO_BY_FIELD } from './asiento-despacho';
import { ImportacionesService } from './services/importaciones.service';

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

/**
 * Asiento del despacho (plan Task 11; spec punto 5, D5, B8, B9; preflight F1, F2, F6, F21).
 *
 * Un solo «mundo» con estado: el mismo Prisma de mentira lo usan ImportacionesService (revisión, confirmar, reintento) y
 * el ContabilidadIntegracionService real (armado del asiento, vista previa), armado con `crearIntegracionMock`. Cada
 * concepto mapeado resuelve a `cta-<CONCEPTO>`; el pasivo de cada proveedor, a `cta-PAS-<proveedor>`.
 */

const EMPRESA = 'emp';
const UPDATED_AT = new Date('2026-10-01T12:00:00.000Z');

/** Conceptos de sistema de los tributos: IVA (D3, T9) e IRE no entran al costo. */
const SISTEMA = CONCEPTO_TRIBUTO_BY_FIELD.map(({ codigo }) => ({
  id: `con-${codigo}`,
  codigo,
  nombre: codigo,
  afecta_costo: !['IMP_IVA_IMPORTACION', 'IMP_ANTICIPO_IRE'].includes(codigo),
}));
const MANUALES = [
  { id: 'con-FOB', codigo: 'FOB', afecta_costo: true },
  { id: 'con-HON', codigo: 'HONORARIOS_DESPACHANTE', afecta_costo: true },
  { id: 'con-MUN', codigo: 'TASA_MUNICIPAL', afecta_costo: true },
  { id: 'con-FLE', codigo: 'FLETE_INTERNACIONAL', afecta_costo: true },
];
const CONCEPTOS = new Map([...SISTEMA, ...MANUALES].map((c) => [c.id, c]));

const NOMBRES: Record<string, string> = { 'p-zhang': 'ZHANGZHOU IMPORT CO', 'p-desp': 'DESPACHOS DEL ESTE SRL', 'p-muni': 'MUNICIPALIDAD DE CDE', 'p-flete': 'NAVIERA DEL SUR SA' };

interface Componente {
  id: string;
  concepto_id: string;
  proveedor_id?: string | null;
  importe_gs: number;
  descripcion?: string;
  compra_id?: string | null;
  gasto_id?: string | null;
  asentado_documento_id?: string | null;
}

interface Opciones {
  moneda?: 'PYG' | 'USD';
  despacho?: Record<string, unknown>;
  componentes?: Componente[];
  contabilidad?: boolean;
  faltan?: string[];
  sinPeriodo?: boolean;
  anticipo?: boolean;
  conceptosFaltantes?: string[];
  documentos?: Array<Record<string, any>>;
  asientosManuales?: Array<Record<string, any>>;
  cotizacion?: number | null;
  p2002?: boolean;
  falloAsiento?: Error;
}

/** El caso de DOBA: FOB del exterior, despachante, municipalidad y los tributos del despacho, con IVA 10/5. */
const DOBA: Componente[] = [
  { id: 'c-fob', concepto_id: 'con-FOB', proveedor_id: null, importe_gs: 100_000_000, descripcion: 'Factura del exterior' },
  { id: 'c-hon', concepto_id: 'con-HON', proveedor_id: 'p-desp', importe_gs: 3_000_000, descripcion: 'Honorarios' },
  { id: 'c-mun', concepto_id: 'con-MUN', proveedor_id: 'p-muni', importe_gs: 500_000, descripcion: 'Tasa municipal' },
];
const TRIBUTOS_DOBA = {
  arancel_gs: 10_000_000,
  iva_importacion_gs: 12_000_000,
  iva_importacion_5_gs: 2_000_000,
  isc_gs: 0,
  inc_gs: 0,
  anticipo_ire_gs: 1_500_000,
  tasa_ana_gs: 300_000,
  otros_gs: 0,
};

function mundo(opts: Opciones = {}) {
  const moneda = opts.moneda === 'USD' ? { id: 'mon-usd', codigo: 'USD' } : { id: 'mon-pyg', codigo: 'PYG' };
  const estado = {
    embarque: {
      id: 'emb-1',
      empresa_id: EMPRESA,
      numero: 'IMP-2026-000001',
      estado: 'EN_DESPACHO',
      activo: true,
      proveedor_id: 'p-zhang',
      moneda_id: moneda.id,
      moneda,
      updated_at: UPDATED_AT,
    } as Record<string, any>,
    despacho: {
      id: 'des-1',
      empresa_id: EMPRESA,
      embarque_id: 'emb-1',
      numero_despacho: '26032IC04008192T',
      fecha_despacho: new Date('2026-10-10T00:00:00.000Z'),
      despachante_id: 'p-desp',
      ...TRIBUTOS_DOBA,
      total_tributos_gs: 23_800_000,
      estado: 'BORRADOR',
      usuario_id: 'u-1',
      updated_at: UPDATED_AT,
      asiento_estado: null,
      asiento_codigo: null,
      asiento_mensaje: null,
      ...opts.despacho,
    } as Record<string, any>,
    componentes: (opts.componentes ?? DOBA).map((c, i) => ({
      empresa_id: EMPRESA,
      embarque_id: 'emb-1',
      activo: true,
      compra_id: null,
      gasto_id: null,
      asentado_documento_id: null,
      descripcion: c.id,
      created_at: new Date(Date.UTC(2026, 9, 1, 0, i)),
      concepto: CONCEPTOS.get(c.concepto_id),
      ...c,
    })) as Array<Record<string, any>>,
    bitacora: [] as Array<Record<string, any>>,
    documentos: opts.documentos ?? [],
  };
  let secuencia = 0;
  const coincide = (fila: Record<string, any>, where: Record<string, any> = {}) =>
    Object.entries(where).every(([k, v]) => {
      if (v && typeof v === 'object' && 'in' in v) return (v.in as unknown[]).includes(fila[k]);
      if (v && typeof v === 'object') return true;
      return fila[k] === v;
    });

  const conceptosSistema = SISTEMA.filter((c) => !(opts.conceptosFaltantes ?? []).includes(c.codigo));
  const tablas: any = {
    $executeRaw: jest.fn().mockResolvedValue(undefined),
    imp_config_empresa: { findUnique: jest.fn().mockResolvedValue({ empresa_id: EMPRESA, modulo_operativo_activo: true, perfil_activo: 'AUTOS' }) },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: 'mon-pyg' }) },
    moneda: { findUnique: jest.fn().mockImplementation(({ where }: any) => Promise.resolve(where.id === moneda.id ? { codigo: moneda.codigo } : null)) },
    imp_embarques: {
      findFirst: jest.fn().mockImplementation(() => Promise.resolve({ ...estado.embarque })),
      update: jest.fn().mockImplementation(({ data }: any) => Promise.resolve(Object.assign(estado.embarque, data))),
    },
    imp_despachos: {
      findFirst: jest.fn().mockImplementation(() => Promise.resolve({ ...estado.despacho })),
      findUnique: jest.fn().mockImplementation(() => Promise.resolve({ ...estado.despacho, embarque: { ...estado.embarque } })),
      update: jest.fn().mockImplementation(({ data }: any) => Promise.resolve(Object.assign(estado.despacho, data))),
    },
    imp_conceptos_costo: { findMany: jest.fn().mockResolvedValue(conceptosSistema) },
    imp_componentes_costo: {
      findMany: jest
        .fn()
        .mockImplementation(({ where }: any = {}) =>
          Promise.resolve(estado.componentes.filter((c) => c.activo && (!where?.embarque_id || c.embarque_id === where.embarque_id)).map((c) => ({ ...c }))),
        ),
      findFirst: jest
        .fn()
        .mockImplementation(({ where }: any) =>
          Promise.resolve(estado.componentes.find((c) => c.activo && c.concepto_id === where.concepto_id && c.descripcion === where.descripcion) ?? null),
        ),
      create: jest.fn().mockImplementation(({ data }: any) => {
        const fila = {
          id: `c-trib-${++secuencia}`,
          activo: true,
          compra_id: null,
          gasto_id: null,
          proveedor_id: null,
          asentado_documento_id: null,
          created_at: new Date(Date.UTC(2026, 9, 10, 0, secuencia)),
          concepto: CONCEPTOS.get(data.concepto_id),
          ...data,
        };
        estado.componentes.push(fila);
        return Promise.resolve(fila);
      }),
      update: jest.fn().mockImplementation(({ where, data }: any) => Promise.resolve(Object.assign(estado.componentes.find((c) => c.id === where.id) ?? {}, data))),
      updateMany: jest.fn().mockImplementation(({ where, data }: any) => {
        const filas = estado.componentes.filter((c) => where.id.in.includes(c.id));
        filas.forEach((c) => Object.assign(c, data));
        return Promise.resolve({ count: filas.length });
      }),
    },
    imp_embarques_bitacora: { create: jest.fn().mockImplementation(({ data }: any) => Promise.resolve(estado.bitacora.push(data))) },
    proveedores: {
      findFirst: jest.fn().mockResolvedValue(null),
      findMany: jest.fn().mockImplementation(({ where }: any) => Promise.resolve((where.id.in as string[]).map((id) => ({ id, personas: { razon_social: NOMBRES[id] ?? id } })))),
    },
    tes_movimientos: { findFirst: jest.fn().mockResolvedValue(opts.anticipo ? { id: 'tes-1' } : null) },
    cont_plan_cuentas: {
      findMany: jest
        .fn()
        .mockImplementation(({ where }: any) => Promise.resolve((where.id.in as string[]).map((id) => ({ id, codigo: id.replace('cta-', ''), descripcion: `Cuenta ${id}` })))),
    },
    cont_documentos: {
      findFirst: jest.fn().mockImplementation(({ where }: any) => Promise.resolve(estado.documentos.find((d) => coincide(d, where)) ?? null)),
      findMany: jest.fn().mockImplementation(({ where }: any) => Promise.resolve(estado.documentos.filter((d) => coincide(d, where)))),
      create: jest.fn().mockImplementation(({ data }: any) => {
        if (opts.p2002) throw new Prisma.PrismaClientKnownRequestError('dup', { code: 'P2002', clientVersion: 'x' });
        const doc = { id: `doc-${estado.documentos.length + 1}`, ...data };
        estado.documentos.push(doc);
        return Promise.resolve(doc);
      }),
      update: jest.fn().mockImplementation(({ where, data }: any) => Promise.resolve(Object.assign(estado.documentos.find((d) => d.id === where.id) ?? {}, data))),
    },
    cont_asientos: {
      findMany: jest.fn().mockImplementation(({ where }: any) => {
        if (where?.documento_id === null) return Promise.resolve(opts.asientosManuales ?? []);
        // Complementarios (F6): asientos de documentos imp_componente CONFIRMADO.
        return Promise.resolve(
          estado.documentos
            .filter((d) => where?.documento_id?.in?.includes(d.id) && d.origen_tipo === 'imp_componente' && d.estado === 'CONFIRMADO')
            .map((d) => ({ documento_id: d.id })),
        );
      }),
    },
  };
  const integracion = crearIntegracionMock(tablas, opts.faltan ?? []);
  integracion.tieneModuloContabilidad.mockResolvedValue(opts.contabilidad ?? true);
  integracion.resolverCuentaPasivo = jest.fn().mockImplementation((id: string) => Promise.resolve(`cta-PAS-${id}`));
  integracion.asientos.crearConfirmado.mockImplementation(() => (opts.falloAsiento ? Promise.reject(opts.falloAsiento) : Promise.resolve({ id: 'as-1', numero: 42 })));
  if (opts.sinPeriodo) {
    integracion.periodos.resolverPeriodoPorFecha.mockRejectedValue(new BadRequestException('No existe un período contable abierto para la fecha 2026-10-10'));
  }
  const prisma = integracion.prisma;
  const tipoCambio = {
    getTasa: jest.fn().mockImplementation((_e: string, codigo: string, fecha: Date) => {
      if (codigo === 'PYG') return Promise.resolve(1);
      if (opts.cotizacion === null || opts.cotizacion === undefined) {
        return Promise.reject(new NotFoundException(`No hay tipo de cambio registrado para ${codigo} en la fecha ${fecha.toISOString().slice(0, 10)}`));
      }
      return Promise.resolve(opts.cotizacion);
    }),
  };
  const costeo = { recalcular: jest.fn().mockResolvedValue(undefined) };
  const service = new ImportacionesService(prisma, costeo as any, tipoCambio as any, integracion, {} as any, {} as any, {} as any);
  return { service, integracion, prisma, estado, costeo };
}

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

/** Líneas del asiento grabado: [cuenta, debe, haber]. */
const lineas = (integracion: any) => integracion.asientos.crearConfirmado.mock.calls[0][3].lineas.map((l: any) => [l.cuenta_id, l.debe_moneda, l.haber_moneda]);
const glosas = (integracion: any) => integracion.asientos.crearConfirmado.mock.calls[0][3].lineas.map((l: any) => l.descripcion);
const eventos = (estado: any) => estado.bitacora.map((b: any) => b.evento);
const confirmar = (s: ImportacionesService) => s.confirmarDespacho('emb-1', 'des-1', EMPRESA, 'u-1');

describe('Importaciones — revisión del despacho', () => {
  it('revisión con un manual sin proveedor lista COMPONENTE_SIN_PROVEEDOR con linea y confirmar responde 400 con errores', async () => {
    const componentes = [...DOBA, { id: 'c-flete', concepto_id: 'con-FLE', proveedor_id: null, importe_gs: 2_000_000 }];
    const { service, estado } = mundo({ componentes });
    const r = await service.revisionDespacho('emb-1', 'des-1', EMPRESA);
    expect(r.errores).toEqual([expect.objectContaining({ codigo: 'COMPONENTE_SIN_PROVEEDOR', linea: 4, componente_id: 'c-flete', message: expect.any(String) })]);

    const e = await cuerpo(confirmar(service));
    expect(e).toMatchObject({ status: 400, codigo: 'COMPONENTE_SIN_PROVEEDOR', linea: 4 });
    expect(e.errores).toHaveLength(1);
    expect(estado.despacho.estado).toBe('BORRADOR');
    expect(estado.embarque.estado).toBe('EN_DESPACHO');
  });

  it('la línea del componente cuenta también los costos con comprobante (orden de la pantalla)', async () => {
    const componentes = [
      { id: 'c-fact', concepto_id: 'con-FOB', proveedor_id: 'p-zhang', importe_gs: 1_000, compra_id: 'compra-1' },
      { id: 'c-flete', concepto_id: 'con-FLE', proveedor_id: null, importe_gs: 2_000 },
    ];
    const { service } = mundo({ componentes });
    const r = await service.revisionDespacho('emb-1', 'des-1', EMPRESA);
    expect(r.errores).toEqual([expect.objectContaining({ codigo: 'COMPONENTE_SIN_PROVEEDOR', linea: 2 })]);
  });

  it('revisión en USD sin cotización del día → COTIZACION_REQUERIDA', async () => {
    const { service } = mundo({ moneda: 'USD', cotizacion: null });
    const r = await service.revisionDespacho('emb-1', 'des-1', EMPRESA);
    expect(r.cotizacion).toBeNull();
    expect(r.moneda_embarque).toEqual({ codigo: 'USD' });
    expect(r.errores.map((x) => x.codigo)).toEqual(['COTIZACION_REQUERIDA']);
    const e = await cuerpo(confirmar(service));
    expect(e).toMatchObject({ status: 400, codigo: 'COTIZACION_REQUERIDA' });
  });

  it('en USD con cotización: confirmar guarda la de la moneda del embarque; en la moneda base, sin cotización', async () => {
    const usd = mundo({ moneda: 'USD', cotizacion: 7300 });
    expect((await usd.service.revisionDespacho('emb-1', 'des-1', EMPRESA)).cotizacion).toBe('7300');
    await confirmar(usd.service);
    expect(usd.estado.despacho.cotizacion_usada).toBe(7300);

    const pyg = mundo();
    expect((await pyg.service.revisionDespacho('emb-1', 'des-1', EMPRESA)).cotizacion).toBeNull();
    await confirmar(pyg.service);
    expect(pyg.estado.despacho.cotizacion_usada).toBeNull();
  });

  it('concepto de tributo inexistente → CONCEPTO_TRIBUTO_FALTANTE (no se saltea en silencio)', async () => {
    const { service, estado } = mundo({ conceptosFaltantes: ['IMP_TASA_ANA'] });
    const r = await service.revisionDespacho('emb-1', 'des-1', EMPRESA);
    expect(r.errores).toEqual([expect.objectContaining({ codigo: 'CONCEPTO_TRIBUTO_FALTANTE', campo: 'tasa_ana_gs' })]);
    expect(r.errores[0].message).toContain('IMP_TASA_ANA');
    const e = await cuerpo(confirmar(service));
    expect(e).toMatchObject({ status: 400, codigo: 'CONCEPTO_TRIBUTO_FALTANTE' });
    expect(estado.componentes.filter((c) => c.id.startsWith('c-trib'))).toHaveLength(0);
  });

  it('sin despachante, sin anticipo: TRIBUTOS_SIN_CONTRAPARTIDA y confirmar bloquea (fila 10)', async () => {
    const { service } = mundo({ despacho: { despachante_id: null } });
    const r = await service.revisionDespacho('emb-1', 'des-1', EMPRESA);
    expect(r.errores.map((x) => x.codigo)).toEqual(['TRIBUTOS_SIN_CONTRAPARTIDA']);
    expect((await cuerpo(confirmar(service))).codigo).toBe('TRIBUTOS_SIN_CONTRAPARTIDA');
  });

  it('la vista previa trae total, tributos y las líneas del asiento con su cuenta, sin escribir', async () => {
    const { service, integracion, prisma } = mundo({ faltan: ['IVA_CREDITO_5'] });
    const r = await service.revisionDespacho('emb-1', 'des-1', EMPRESA);
    expect(r.total_tributos).toBe('23800000');
    expect(r.tributos).toContainEqual({ campo: 'iva_importacion_gs', monto: '12000000' });
    expect(r.asiento?.faltantes).toEqual(['IVA_CREDITO_5']);
    const iva5 = r.asiento?.lineas.find((l) => l.concepto === 'IVA_CREDITO_5');
    expect(iva5).toMatchObject({ cuenta: null, debe: '2000000.00', haber: '0.00' });
    expect(r.asiento?.lineas.find((l) => l.concepto === 'IVA_CREDITO_10')?.cuenta).toEqual({
      id: 'cta-IVA_CREDITO_10',
      codigo: 'IVA_CREDITO_10',
      nombre: 'Cuenta cta-IVA_CREDITO_10',
    });
    expect(integracion.asientos.crearConfirmado).not.toHaveBeenCalled();
    expect(prisma.cont_documentos.create).not.toHaveBeenCalled();
    expect(prisma.imp_componentes_costo.create).not.toHaveBeenCalled();
  });

  it('sin Contabilidad → la revisión no trae asiento ni errores de asiento, y confirmar da NO_APLICA (fila 7)', async () => {
    const { service, estado, integracion } = mundo({ contabilidad: false, despacho: { despachante_id: null } });
    const r = await service.revisionDespacho('emb-1', 'des-1', EMPRESA);
    expect(r.asiento).toBeNull();
    expect(r.errores).toEqual([]);
    const res = await confirmar(service);
    expect(res.asiento).toEqual({ estado: 'NO_APLICA' });
    expect(estado.despacho.asiento_estado).toBe('NO_APLICA');
    expect(integracion.asientos.crearConfirmado).not.toHaveBeenCalled();
    expect(eventos(estado)).not.toContain('ASIENTO_FALLIDO');
  });
});

describe('Importaciones — asiento del despacho al confirmar', () => {
  it('caso DOBA: FOB al proveedor del exterior, despachante, municipalidad, tributos al despachante e IVA 10/5', async () => {
    const { service, integracion, estado } = mundo();
    const res = await confirmar(service);
    expect(res.embarque_estado).toBe('DESPACHADO');
    expect(res.asiento).toEqual({ estado: 'GENERADO', documento_id: 'doc-1', numero: '42' });
    expect(lineas(integracion)).toEqual([
      ['cta-IMPORTACION_TRIBUTOS', 113_800_000, 0],
      ['cta-IVA_CREDITO_10', 10_000_000, 0],
      ['cta-IVA_CREDITO_5', 2_000_000, 0],
      ['cta-IMPORTACION_ANTICIPO_IRE', 1_500_000, 0],
      ['cta-PAS-p-zhang', 0, 100_000_000],
      ['cta-PAS-p-desp', 0, 3_000_000],
      ['cta-PAS-p-muni', 0, 500_000],
      ['cta-PAS-p-desp', 0, 23_800_000],
    ]);
    expect(glosas(integracion).slice(4)).toEqual([
      'ZHANGZHOU IMPORT CO (despacho 26032IC04008192T)',
      'DESPACHOS DEL ESTE SRL (despacho 26032IC04008192T)',
      'MUNICIPALIDAD DE CDE (despacho 26032IC04008192T)',
      'Tributos del despacho 26032IC04008192T (DESPACHOS DEL ESTE SRL)',
    ]);
    expect(estado.despacho).toMatchObject({ estado: 'CONFIRMADO', asiento_estado: 'GENERADO', asiento_codigo: null, asiento_mensaje: null });
  });

  it('tres proveedores, tres líneas de haber; el FOB sin proveedor al del embarque (fila 15)', async () => {
    const componentes = [
      { id: 'c-fob', concepto_id: 'con-FOB', proveedor_id: null, importe_gs: 1_000 },
      { id: 'c-flete', concepto_id: 'con-FLE', proveedor_id: 'p-flete', importe_gs: 200 },
      { id: 'c-hon', concepto_id: 'con-HON', proveedor_id: 'p-desp', importe_gs: 50 },
      { id: 'c-hon2', concepto_id: 'con-HON', proveedor_id: 'p-desp', importe_gs: 25 },
    ];
    const { service, integracion } = mundo({ componentes, despacho: { ...ceros() } });
    await confirmar(service);
    expect(lineas(integracion).filter((l: any) => l[2] > 0)).toEqual([
      ['cta-PAS-p-zhang', 0, 1_000],
      ['cta-PAS-p-flete', 0, 200],
      ['cta-PAS-p-desp', 0, 75],
    ]);
  });

  it('un tributo con proveedor va a la línea de su proveedor, no a la de tributos (F21)', async () => {
    const componentes = [{ id: 'c-arancel-prov', concepto_id: 'con-IMP_ARANCEL', proveedor_id: 'p-muni', importe_gs: 300 }];
    const { service, integracion } = mundo({ componentes, despacho: { ...ceros() } });
    await confirmar(service);
    expect(lineas(integracion)).toEqual([
      ['cta-IMPORTACION_TRIBUTOS', 300, 0],
      ['cta-PAS-p-muni', 0, 300],
    ]);
  });

  it('tributos con anticipo y puente contra ANTICIPO_DESPACHO; sin anticipo contra el despachante (filas 9 y 10)', async () => {
    const con = mundo({ componentes: [], anticipo: true, despacho: { ...ceros(), arancel_gs: 1_000, total_tributos_gs: 1_000 } });
    await confirmar(con.service);
    expect(lineas(con.integracion)).toEqual([
      ['cta-IMPORTACION_TRIBUTOS', 1_000, 0],
      ['cta-ANTICIPO_DESPACHO', 0, 1_000],
    ]);

    const sin = mundo({ componentes: [], anticipo: false, despacho: { ...ceros(), arancel_gs: 1_000, total_tributos_gs: 1_000 } });
    await confirmar(sin.service);
    expect(lineas(sin.integracion)).toEqual([
      ['cta-IMPORTACION_TRIBUTOS', 1_000, 0],
      ['cta-PAS-p-desp', 0, 1_000],
    ]);

    // Con anticipo pero sin cuenta puente, la regla de hoy: va al despachante.
    const sinPuente = mundo({ componentes: [], anticipo: true, faltan: ['IMPORTACIONES_EN_CURSO'], despacho: { ...ceros(), arancel_gs: 1_000, total_tributos_gs: 1_000 } });
    await confirmar(sinPuente.service);
    expect(lineas(sinPuente.integracion)[1]).toEqual(['cta-PAS-p-desp', 0, 1_000]);
  });

  it('IVA 30 de 100 al 5 %: dos líneas; solo 10 %: una (fila 14)', async () => {
    const dos = mundo({ componentes: [], despacho: { ...ceros(), iva_importacion_gs: 100, iva_importacion_5_gs: 30, total_tributos_gs: 100 } });
    await confirmar(dos.service);
    expect(lineas(dos.integracion)).toEqual([
      ['cta-IVA_CREDITO_10', 70, 0],
      ['cta-IVA_CREDITO_5', 30, 0],
      ['cta-PAS-p-desp', 0, 100],
    ]);

    const una = mundo({ componentes: [], despacho: { ...ceros(), iva_importacion_gs: 100, iva_importacion_5_gs: 0, total_tributos_gs: 100 } });
    await confirmar(una.service);
    expect(lineas(una.integracion)).toEqual([
      ['cta-IVA_CREDITO_10', 100, 0],
      ['cta-PAS-p-desp', 0, 100],
    ]);
  });

  it('con IVA afecta_costo false: IVA solo en crédito fiscal, IRE solo con el anticipo, debe del costo = costeo (F2)', async () => {
    const { service, integracion } = mundo({
      componentes: [{ id: 'c-fob', concepto_id: 'con-FOB', importe_gs: 1_000 }],
      despacho: { ...ceros(), iva_importacion_gs: 110, anticipo_ire_gs: 40, total_tributos_gs: 150 },
    });
    await confirmar(service);
    const l = lineas(integracion);
    // Lo que entra al costo (costeo): FOB 1000. El IVA (110) no se debita dos veces ni baja el inventario.
    expect(l).toEqual([
      ['cta-IMPORTACION_TRIBUTOS', 1_000, 0],
      ['cta-IVA_CREDITO_10', 110, 0],
      ['cta-IMPORTACION_ANTICIPO_IRE', 40, 0],
      ['cta-PAS-p-zhang', 0, 1_000],
      ['cta-PAS-p-desp', 0, 150],
    ]);
  });

  it('tributos todos en 0: sin IVA ni tributos, solo las de proveedores; con todo en 0 no hay documento (NO_APLICA)', async () => {
    const solo = mundo({ componentes: [{ id: 'c-fob', concepto_id: 'con-FOB', importe_gs: 500 }], despacho: { ...ceros(), despachante_id: null } });
    expect((await solo.service.revisionDespacho('emb-1', 'des-1', EMPRESA)).errores).toEqual([]);
    await confirmar(solo.service);
    expect(lineas(solo.integracion)).toEqual([
      ['cta-IMPORTACION_TRIBUTOS', 500, 0],
      ['cta-PAS-p-zhang', 0, 500],
    ]);
    expect(solo.estado.componentes.filter((c) => c.id.startsWith('c-trib'))).toHaveLength(0);

    const nada = mundo({ componentes: [], despacho: { ...ceros(), despachante_id: null } });
    const res = await confirmar(nada.service);
    expect(res.asiento).toEqual({ estado: 'NO_APLICA' });
    expect(nada.prisma.cont_documentos.create).not.toHaveBeenCalled();
  });

  it('haber de un componente USD suma importe_gs (embarque PYG, flete en USD)', async () => {
    const componentes = [{ id: 'c-flete', concepto_id: 'con-FLE', proveedor_id: 'p-flete', importe_gs: 7_300_000, importe: 1_000, cotizacion: 7300 } as any];
    const { service, integracion } = mundo({ componentes, despacho: { ...ceros() } });
    await confirmar(service);
    expect(lineas(integracion)).toEqual([
      ['cta-IMPORTACION_TRIBUTOS', 7_300_000, 0],
      ['cta-PAS-p-flete', 0, 7_300_000],
    ]);
  });

  describe('redondeo por proveedor: el asiento cuadra al céntimo (3 proveedores en USD, IVA 10 y 5)', () => {
    const COTIZACION = 7312.4733;
    const r4 = (n: number) => Math.round(n * 10_000) / 10_000;
    const centimos = (n: number) => Math.round(n * 100);
    // Importes USD que no dan un número redondo en guaraníes: FOB sin proveedor (va a ZHANGZHOU), flete y tasa municipal.
    const USD = [
      { id: 'c-fob', concepto_id: 'con-FOB', proveedor_id: null, importe: 1000.0001 },
      { id: 'c-flete', concepto_id: 'con-FLE', proveedor_id: 'p-flete', importe: 333.3333 },
      { id: 'c-mun', concepto_id: 'con-MUN', proveedor_id: 'p-muni', importe: 98.7659 },
    ];
    const TRIBUTOS = {
      ...ceros(),
      arancel_gs: 523_609.39,
      iva_importacion_gs: 1_047_218.79,
      iva_importacion_5_gs: 300_000.33,
      anticipo_ire_gs: 104_721.88,
      total_tributos_gs: 1_675_550.06,
    };
    const sumas = (ls: Array<[string, number, number]>) => ({ debe: ls.reduce((s, l) => s + centimos(l[1]), 0), haber: ls.reduce((s, l) => s + centimos(l[2]), 0) });

    it('con el importe_gs que graba el alta (entero): cuadra', async () => {
      const componentes = USD.map((c) => ({ ...c, cotizacion: COTIZACION, importe_gs: Math.round(c.importe * COTIZACION) }) as any);
      const { service, integracion } = mundo({ moneda: 'USD', cotizacion: COTIZACION, componentes, despacho: TRIBUTOS });
      await confirmar(service);
      const ls = lineas(integracion);
      const { debe, haber } = sumas(ls);
      expect(debe).toBe(haber);
      expect(ls.filter((l: any) => l[0] === 'cta-IVA_CREDITO_5')).toEqual([['cta-IVA_CREDITO_5', 300_000.33, 0]]);
    });

    it('con importe_gs a 4 decimales (lo que admite la columna, datos legados): cuadra y el residuo va a la línea de costo, nunca al IVA ni a un proveedor', async () => {
      const componentes = USD.map((c) => ({ ...c, cotizacion: COTIZACION, importe_gs: r4(c.importe * COTIZACION) }) as any);
      // 7.312.474,0312 + 2.437.490,8563 + 722.223,0067 = 10.472.187,8942 → 10.472.187,89; por proveedor redondea a ,03 + ,86 + ,01 = ,90.
      const { service, integracion } = mundo({ moneda: 'USD', cotizacion: COTIZACION, componentes, despacho: TRIBUTOS });
      await confirmar(service);
      const ls = lineas(integracion);
      const { debe, haber } = sumas(ls);
      expect(debe).toBe(haber);
      // Cada proveedor recibe exactamente lo suyo, redondeado una vez (es lo que se le debe).
      expect(ls.filter((l: any) => l[2] > 0)).toEqual([
        ['cta-PAS-p-zhang', 0, 7_312_474.03],
        ['cta-PAS-p-flete', 0, 2_437_490.86],
        ['cta-PAS-p-muni', 0, 722_223.01],
        ['cta-PAS-p-desp', 0, 1_675_550.06],
      ]);
      // IVA e IRE tal cual el despacho; la línea de costo absorbe el céntimo.
      expect(ls.filter((l: any) => l[0] !== 'cta-IMPORTACION_TRIBUTOS' && l[1] > 0)).toEqual([
        ['cta-IVA_CREDITO_10', 747_218.46, 0],
        ['cta-IVA_CREDITO_5', 300_000.33, 0],
        ['cta-IMPORTACION_ANTICIPO_IRE', 104_721.88, 0],
      ]);
    });

    it('la vista previa muestra el mismo asiento cuadrado', async () => {
      const componentes = USD.map((c) => ({ ...c, cotizacion: COTIZACION, importe_gs: r4(c.importe * COTIZACION) }) as any);
      const { service } = mundo({ moneda: 'USD', cotizacion: COTIZACION, componentes, despacho: TRIBUTOS });
      const r = await service.revisionDespacho('emb-1', 'des-1', EMPRESA);
      const ls = r.asiento!.lineas;
      expect(ls.reduce((s, l) => s + centimos(Number(l.debe)), 0)).toBe(ls.reduce((s, l) => s + centimos(Number(l.haber)), 0));
    });
  });

  it('sin período → PENDIENTE PERIODO_CERRADO, el despacho queda CONFIRMADO y el evento ASIENTO_FALLIDO (fila 12)', async () => {
    const { service, estado, integracion } = mundo({ sinPeriodo: true });
    const res = await confirmar(service);
    expect(res.asiento).toEqual({ estado: 'PENDIENTE', codigo: 'PERIODO_CERRADO', mensaje: expect.stringContaining('2026-10-10') });
    expect(integracion.asientos.crearConfirmado).not.toHaveBeenCalled();
    expect(estado.despacho).toMatchObject({ estado: 'CONFIRMADO', asiento_estado: 'PENDIENTE', asiento_codigo: 'PERIODO_CERRADO' });
    expect(estado.embarque.estado).toBe('DESPACHADO');
    const fallido = estado.bitacora.find((b) => b.evento === 'ASIENTO_FALLIDO');
    expect(fallido?.detalle).toMatchObject({ despacho_id: 'des-1', codigo: 'PERIODO_CERRADO' });
  });

  it('falta IVA_CREDITO_5 → PENDIENTE MAPEO_FALTANTE y aviso registrado (fila 11)', async () => {
    const { service, estado, integracion } = mundo({ faltan: ['IVA_CREDITO_5'] });
    const res = await confirmar(service);
    expect(res.asiento).toMatchObject({ estado: 'PENDIENTE', codigo: 'MAPEO_FALTANTE', mensaje: expect.stringContaining('IVA_CREDITO_5') });
    expect(integracion.avisosMapeo.registrarFaltaMapeo).toHaveBeenCalledWith(
      expect.objectContaining({ empresaId: EMPRESA, origenTipo: 'imp_despacho', origenId: 'des-1', conceptos: ['IVA_CREDITO_5'] }),
    );
    expect(estado.despacho).toMatchObject({ asiento_estado: 'PENDIENTE', asiento_codigo: 'MAPEO_FALTANTE' });
    expect(eventos(estado)).toContain('ASIENTO_FALLIDO');
  });

  it('sin parte al 5 % no exige IVA_CREDITO_5', async () => {
    const { service } = mundo({ faltan: ['IVA_CREDITO_5'], despacho: { iva_importacion_5_gs: 0 } });
    expect((await confirmar(service)).asiento.estado).toBe('GENERADO');
  });

  it('confirmar dos veces: la segunda recibe ESTADO_CAMBIADO con estado_actual (F9) y no repite nada', async () => {
    const { service, integracion, prisma } = mundo();
    await confirmar(service);
    const e = await cuerpo(confirmar(service));
    expect(e).toMatchObject({ status: 409, codigo: 'ESTADO_CAMBIADO', estado_actual: 'DESPACHADO', estado_pedido: 'DESPACHADO' });
    expect(integracion.asientos.crearConfirmado).toHaveBeenCalledTimes(1);
    expect(prisma.$executeRaw).toHaveBeenCalled(); // lock imp: antes de releer
  });

  it('los componentes asentados guardan el documento (B3); los de un comprobante no', async () => {
    const componentes = [...DOBA, { id: 'c-fact', concepto_id: 'con-FOB', proveedor_id: 'p-zhang', importe_gs: 9_999, compra_id: 'compra-1' }];
    const { service, estado } = mundo({ componentes });
    await confirmar(service);
    const asentados = estado.componentes.filter((c) => c.asentado_documento_id === 'doc-1').map((c) => c.id);
    expect(asentados).toEqual(expect.arrayContaining(['c-fob', 'c-hon', 'c-mun']));
    expect(asentados.filter((id) => id.startsWith('c-trib'))).toHaveLength(4); // arancel, IVA, IRE, tasa ANA
    expect(estado.componentes.find((c) => c.id === 'c-fact')?.asentado_documento_id).toBeNull();
  });

  it('el armado excluye los costos ya asentados por su complementario CONFIRMADO (F6)', async () => {
    const componentes = [
      { id: 'c-fob', concepto_id: 'con-FOB', importe_gs: 1_000 },
      { id: 'c-tarde', concepto_id: 'con-FLE', proveedor_id: 'p-flete', importe_gs: 300, asentado_documento_id: 'doc-comp' },
      { id: 'c-rev', concepto_id: 'con-HON', proveedor_id: 'p-desp', importe_gs: 70, asentado_documento_id: 'doc-comp-rev' },
    ];
    const documentos = [
      { id: 'doc-comp', empresa_id: EMPRESA, origen_tipo: 'imp_componente', origen_id: 'c-tarde', estado: 'CONFIRMADO' },
      { id: 'doc-comp-rev', empresa_id: EMPRESA, origen_tipo: 'imp_componente', origen_id: 'c-rev', estado: 'REVERTIDO' },
    ];
    const { service, integracion } = mundo({ componentes, documentos, despacho: { ...ceros() } });
    await confirmar(service);
    expect(lineas(integracion)).toEqual([
      ['cta-IMPORTACION_TRIBUTOS', 1_070, 0],
      ['cta-PAS-p-zhang', 0, 1_000],
      ['cta-PAS-p-desp', 0, 70],
    ]);
  });

  it('ningún catch vacío en confirmar: el error del asiento no rompe la respuesta y queda guardado', async () => {
    const { service, estado } = mundo({ falloAsiento: new Error('La cuenta 2.1.1 está inactiva') });
    const res = await confirmar(service);
    expect(res.embarque_estado).toBe('DESPACHADO');
    expect(res.asiento).toEqual({ estado: 'PENDIENTE', codigo: 'ASIENTO_ERROR', mensaje: 'La cuenta 2.1.1 está inactiva' });
    expect(estado.despacho).toMatchObject({ asiento_estado: 'PENDIENTE', asiento_codigo: 'ASIENTO_ERROR', asiento_mensaje: 'La cuenta 2.1.1 está inactiva' });
    expect(eventos(estado)).toContain('ASIENTO_FALLIDO');
  });

  it('el servicio no tiene catch vacíos ni .catch(() => …) mudos', () => {
    const fuente = readFileSync(join(__dirname, 'services/importaciones.service.ts'), 'utf8');
    expect(fuente).not.toMatch(/catch\s*\{/);
    expect(fuente).not.toMatch(/\.catch\(\s*\(\s*\)\s*=>/);
  });
});

describe('Importaciones — reintentar el asiento del despacho', () => {
  const confirmado = { estado: 'CONFIRMADO', confirmado_at: new Date('2026-10-10T12:00:00Z'), asiento_estado: 'PENDIENTE', asiento_codigo: 'ASIENTO_REVERTIDO' };
  const asentados = () => DOBA.map((c) => ({ ...c, asentado_documento_id: 'doc-viejo' }));
  const revertido = {
    id: 'doc-viejo',
    empresa_id: EMPRESA,
    origen_tipo: 'imp_despacho',
    origen_id: 'des-1',
    estado: 'REVERTIDO',
    asiento: { glosa: 'Cierre despacho importación 26032IC04008192T (embarque IMP-2026-000001)', updated_at: new Date('2026-10-12T00:00:00Z') },
  };
  const reintentar = (s: ImportacionesService) => s.reintegrarContabilidadDespacho('emb-1', 'des-1', EMPRESA, 'u-1');

  it('reintento con documento REVERTIDO lo desvincula y genera otro (fila 13, B9)', async () => {
    const { service, estado, integracion } = mundo({ componentes: asentados(), despacho: { ...confirmado, ...ceros() }, documentos: [{ ...revertido }] });
    estado.embarque.estado = 'DESPACHADO';
    const res = await reintentar(service);
    expect(res.asiento).toEqual({ estado: 'GENERADO', documento_id: 'doc-2', numero: '42' });
    expect(estado.documentos.find((d) => d.id === 'doc-viejo')).toMatchObject({ estado: 'REVERTIDO', origen_tipo: null, origen_id: null });
    expect(integracion.asientos.crearConfirmado).toHaveBeenCalledTimes(1);
    expect(estado.componentes.every((c) => c.asentado_documento_id === 'doc-2')).toBe(true);
    expect(estado.despacho).toMatchObject({ asiento_estado: 'GENERADO', asiento_codigo: null });
    expect(estado.bitacora.find((b) => b.evento === 'ASIENTO_REINTENTADO')?.detalle).toMatchObject({ despacho_id: 'des-1', estado: 'GENERADO' });
  });

  it('con uno CONFIRMADO → ASIENTO_YA_GENERADO con su número', async () => {
    const documentos = [{ id: 'doc-ok', empresa_id: EMPRESA, origen_tipo: 'imp_despacho', origen_id: 'des-1', estado: 'CONFIRMADO', asiento: { numero: 17 } }];
    const { service, integracion } = mundo({ despacho: confirmado, documentos });
    const e = await cuerpo(reintentar(service));
    expect(e).toMatchObject({ status: 409, codigo: 'ASIENTO_YA_GENERADO', numero: '17' });
    expect(integracion.asientos.crearConfirmado).not.toHaveBeenCalled();
  });

  it('con corrección manual del revertido (caso DOBA) → ASIENTO_YA_GENERADO sin generar otro (F1)', async () => {
    const manual = { id: 'as-manual', numero: 88, glosa: `CORRECCIÓN: ${revertido.asiento.glosa}`, created_at: new Date('2026-10-13T00:00:00Z') };
    const { service, estado, integracion } = mundo({ despacho: confirmado, documentos: [{ ...revertido }], asientosManuales: [manual] });
    const e = await cuerpo(reintentar(service));
    expect(e).toMatchObject({ status: 409, codigo: 'ASIENTO_YA_GENERADO', numero: '88', motivo: 'CORRECCION_MANUAL' });
    expect(integracion.asientos.crearConfirmado).not.toHaveBeenCalled();
    expect(estado.documentos[0]).toMatchObject({ origen_id: 'des-1' }); // el revertido sigue vinculado
    expect(estado.despacho).toMatchObject({ asiento_estado: 'GENERADO', asiento_codigo: 'CORRECCION_MANUAL' });
  });

  it('P2002 en el reintento (dos a la vez) → ASIENTO_YA_GENERADO', async () => {
    const { service } = mundo({ despacho: confirmado, documentos: [{ ...revertido }], p2002: true });
    const e = await cuerpo(reintentar(service));
    expect(e).toMatchObject({ status: 409, codigo: 'ASIENTO_YA_GENERADO' });
  });

  it('el reintento que vuelve a fallar guarda el nuevo código y deja el evento', async () => {
    const { service, estado } = mundo({ despacho: confirmado, sinPeriodo: true });
    const res = await reintentar(service);
    expect(res.asiento).toMatchObject({ estado: 'PENDIENTE', codigo: 'PERIODO_CERRADO' });
    expect(estado.despacho.asiento_codigo).toBe('PERIODO_CERRADO');
    expect(eventos(estado)).toContain('ASIENTO_REINTENTADO');
  });

  it('un despacho en BORRADOR no se reintenta: ESTADO_CAMBIADO', async () => {
    const { service } = mundo();
    expect(await cuerpo(reintentar(service))).toMatchObject({ status: 409, codigo: 'ESTADO_CAMBIADO' });
  });
});

describe('Conciliación y recontabilización siguen llamando a integrarCierreDespacho por nombre', () => {
  it('con la falta de mapeo como error (Conciliación), la falta se relanza y deja su aviso', async () => {
    const { integracion, estado } = mundo({ faltan: ['IVA_CREDITO_5'], despacho: { estado: 'CONFIRMADO' } });
    estado.componentes.push(
      ...CONCEPTO_TRIBUTO_BY_FIELD.filter(({ field }) => Number(TRIBUTOS_DOBA[field]) > 0).map(({ field, codigo }) => ({
        id: `c-${field}`,
        activo: true,
        empresa_id: EMPRESA,
        embarque_id: 'emb-1',
        compra_id: null,
        gasto_id: null,
        proveedor_id: null,
        asentado_documento_id: null,
        importe_gs: TRIBUTOS_DOBA[field],
        descripcion: 'Despacho 26032IC04008192T',
        created_at: new Date(),
        concepto: CONCEPTOS.get(`con-${codigo}`),
      })),
    );
    const estricto = conFaltaDeMapeoComoError(integracion, { registrar: true });
    await expect(estricto.integrarCierreDespacho('des-1')).rejects.toBeInstanceOf(FaltaMapeoError);
    expect(integracion.avisosMapeo.registrarFaltaMapeo).toHaveBeenCalled();
  });

  it('el despacho confirmado con su documento CONFIRMADO no genera otro (idempotente)', async () => {
    const documentos = [{ id: 'doc-ok', empresa_id: EMPRESA, origen_tipo: 'imp_despacho', origen_id: 'des-1', estado: 'CONFIRMADO', asiento: { numero: 5 } }];
    const { integracion } = mundo({ despacho: { estado: 'CONFIRMADO' }, documentos });
    await expect(integracion.integrarCierreDespacho('des-1')).resolves.toEqual({ estado: 'GENERADO', documento_id: 'doc-ok', numero: '5' });
    expect(integracion.asientos.crearConfirmado).not.toHaveBeenCalled();
  });
});

/** Tributos del despacho en 0 (sobre el despacho de DOBA). */
function ceros() {
  return { arancel_gs: 0, iva_importacion_gs: 0, iva_importacion_5_gs: 0, isc_gs: 0, inc_gs: 0, anticipo_ire_gs: 0, tasa_ana_gs: 0, otros_gs: 0, total_tributos_gs: 0 };
}
