import { CODIGOS_TRIBUTO, CONCEPTO_TRIBUTO_BY_FIELD, ComponenteAsiento, agruparHaberDespacho, repartirIva } from './asiento-despacho';
import { CODIGOS_TRIBUTO as CODIGOS_TRIBUTO_DTO, IMP_ESTADOS_DESPACHO } from './dto/importaciones.dto';

const ctx = { proveedorEmbarqueId: 'prov-emb', despachanteId: 'desp' as string | null, hayAnticipoDespacho: false, hayCuentaPuente: false };
const c = (id: string, linea: number, concepto: string, proveedor: string | null, importe: number): ComponenteAsiento => ({
  id, linea, concepto_codigo: concepto, proveedor_id: proveedor, importe_gs: importe,
});

describe('CODIGOS_TRIBUTO (F21)', () => {
  it('es una sola lista: derivada de CONCEPTO_TRIBUTO_BY_FIELD y la misma que exporta el DTO', () => {
    expect(CODIGOS_TRIBUTO).toEqual(CONCEPTO_TRIBUTO_BY_FIELD.map((x) => x.codigo));
    expect(CODIGOS_TRIBUTO_DTO).toBe(CODIGOS_TRIBUTO);
    expect(CODIGOS_TRIBUTO).toEqual(expect.arrayContaining(['IMP_ARANCEL', 'IMP_IVA_IMPORTACION', 'IMP_ISC', 'IMP_INC', 'IMP_ANTICIPO_IRE', 'IMP_TASA_ANA', 'IMP_OTROS_TRIBUTOS']));
    expect(IMP_ESTADOS_DESPACHO).toEqual(['BORRADOR', 'CONFIRMADO']);
  });
});

describe('agruparHaberDespacho', () => {
  it('tres proveedores, tres líneas (suma los componentes de cada uno)', () => {
    const r = agruparHaberDespacho(
      [c('a', 1, 'FLETE', 'p1', 1000), c('b', 2, 'SEGURO', 'p2', 200), c('c', 3, 'FLETE', 'p1', 500), c('d', 4, 'ALMACEN', 'p3', 50)],
      ctx,
    );
    expect(r.errores).toEqual([]);
    expect(r.haber).toEqual([
      { tipo: 'PROVEEDOR', proveedor_id: 'p1', monto: 1500, componentes: ['a', 'c'] },
      { tipo: 'PROVEEDOR', proveedor_id: 'p2', monto: 200, componentes: ['b'] },
      { tipo: 'PROVEEDOR', proveedor_id: 'p3', monto: 50, componentes: ['d'] },
    ]);
  });

  it('FOB sin proveedor va al del embarque (y se junta con sus propios componentes)', () => {
    const r = agruparHaberDespacho([c('f', 1, 'FOB', null, 9000), c('x', 2, 'FLETE', 'prov-emb', 100)], ctx);
    expect(r.errores).toEqual([]);
    expect(r.haber).toEqual([{ tipo: 'PROVEEDOR', proveedor_id: 'prov-emb', monto: 9100, componentes: ['f', 'x'] }]);
  });

  it('manual sin proveedor → COMPONENTE_SIN_PROVEEDOR con su linea, sin armar parcial de ese componente', () => {
    const r = agruparHaberDespacho([c('a', 1, 'FLETE', 'p1', 100), c('b', 2, 'COMISION', null, 70)], ctx);
    expect(r.errores).toEqual([{ codigo: 'COMPONENTE_SIN_PROVEEDOR', linea: 2, componente_id: 'b' }]);
    expect(r.haber.find((h) => h.monto === 70)).toBeUndefined();
  });

  it('tributos con anticipo y puente → ANTICIPO_DESPACHO; sin anticipo → DESPACHANTE; sin despachante → TRIBUTOS_SIN_CONTRAPARTIDA', () => {
    const trib = [c('t1', 1, 'IMP_ARANCEL', null, 300), c('t2', 2, 'IMP_IVA_IMPORTACION', null, 700)];
    expect(agruparHaberDespacho(trib, { ...ctx, hayAnticipoDespacho: true, hayCuentaPuente: true }).haber).toEqual([{ tipo: 'ANTICIPO_DESPACHO', monto: 1000 }]);
    expect(agruparHaberDespacho(trib, ctx).haber).toEqual([{ tipo: 'DESPACHANTE', proveedor_id: 'desp', monto: 1000 }]);
    // anticipo sin cuenta puente (o al revés) no alcanza: cae al despachante.
    expect(agruparHaberDespacho(trib, { ...ctx, hayAnticipoDespacho: true, hayCuentaPuente: false }).haber).toEqual([{ tipo: 'DESPACHANTE', proveedor_id: 'desp', monto: 1000 }]);
    const sin = agruparHaberDespacho(trib, { ...ctx, despachanteId: null });
    expect(sin.haber).toEqual([]);
    expect(sin.errores).toEqual([{ codigo: 'TRIBUTOS_SIN_CONTRAPARTIDA' }]);
  });

  it('F21: un concepto de tributo CON proveedor va a la línea de su proveedor, no a la contrapartida', () => {
    const r = agruparHaberDespacho([c('t', 1, 'IMP_ARANCEL', 'p-arancel', 400), c('u', 2, 'IMP_ISC', null, 100)], ctx);
    expect(r.errores).toEqual([]);
    expect(r.haber).toEqual([
      { tipo: 'PROVEEDOR', proveedor_id: 'p-arancel', monto: 400, componentes: ['t'] },
      { tipo: 'DESPACHANTE', proveedor_id: 'desp', monto: 100 },
    ]);
  });

  it('tributos todos en 0: sin línea de tributos y sin error, aunque no haya despachante', () => {
    const r = agruparHaberDespacho([c('t1', 1, 'IMP_ARANCEL', null, 0), c('t2', 2, 'IMP_IVA_IMPORTACION', null, 0), c('a', 3, 'FLETE', 'p1', 80)], { ...ctx, despachanteId: null });
    expect(r.errores).toEqual([]);
    expect(r.haber).toEqual([{ tipo: 'PROVEEDOR', proveedor_id: 'p1', monto: 80, componentes: ['a'] }]);
    expect(agruparHaberDespacho([], { ...ctx, despachanteId: null })).toEqual({ haber: [], errores: [] });
  });

  it('suma sin ruido de coma flotante', () => {
    const r = agruparHaberDespacho([c('a', 1, 'FLETE', 'p1', 0.1), c('b', 2, 'FLETE', 'p1', 0.2)], ctx);
    expect(r.haber).toEqual([{ tipo: 'PROVEEDOR', proveedor_id: 'p1', monto: 0.3, componentes: ['a', 'b'] }]);
  });
});

describe('repartirIva', () => {
  it('reparte el total entre 10 % y 5 %', () => {
    expect(repartirIva(100, 30)).toEqual({ iva10: 70, iva5: 30 });
    expect(repartirIva(100, 0)).toEqual({ iva10: 100, iva5: 0 });
    expect(repartirIva(100, 100)).toEqual({ iva10: 0, iva5: 100 });
    expect(repartirIva(0, 0)).toEqual({ iva10: 0, iva5: 0 });
  });

  it('repartirIva(100, 101) lanza IVA_5_SUPERA_TOTAL (400)', () => {
    try {
      repartirIva(100, 101);
      throw new Error('no lanzó');
    } catch (e) {
      expect((e as { getStatus: () => number }).getStatus()).toBe(400);
      expect((e as { getResponse: () => unknown }).getResponse()).toMatchObject({ codigo: 'IVA_5_SUPERA_TOTAL', campo: 'iva_importacion_5_gs' });
    }
  });

  it('una parte al 5 % negativa o un total negativo también se rechazan', () => {
    expect(() => repartirIva(100, -1)).toThrow();
    expect(() => repartirIva(-1, 0)).toThrow();
  });
});
