import { CODIGOS_IMP, errorImp } from './errores-imp';

/** Campo de `imp_despachos` que se vuelve un componente de tributo al confirmar. */
export type DespachoTributoField =
  | 'arancel_gs'
  | 'iva_importacion_gs'
  | 'isc_gs'
  | 'inc_gs'
  | 'anticipo_ire_gs'
  | 'tasa_ana_gs'
  | 'otros_gs';

/** Campo del despacho -> código del concepto de costo de sistema. Única fuente de la lista de tributos (F21). */
export const CONCEPTO_TRIBUTO_BY_FIELD: ReadonlyArray<{ field: DespachoTributoField; codigo: string }> = [
  { field: 'arancel_gs', codigo: 'IMP_ARANCEL' },
  { field: 'iva_importacion_gs', codigo: 'IMP_IVA_IMPORTACION' },
  { field: 'isc_gs', codigo: 'IMP_ISC' },
  { field: 'inc_gs', codigo: 'IMP_INC' },
  { field: 'anticipo_ire_gs', codigo: 'IMP_ANTICIPO_IRE' },
  { field: 'tasa_ana_gs', codigo: 'IMP_TASA_ANA' },
  { field: 'otros_gs', codigo: 'IMP_OTROS_TRIBUTOS' },
];

/** Códigos de los conceptos de tributo. Un componente es tributo si su concepto está acá Y no tiene proveedor. */
export const CODIGOS_TRIBUTO: readonly string[] = CONCEPTO_TRIBUTO_BY_FIELD.map((c) => c.codigo);

/**
 * Concepto del IVA de importación. No entra al costo (D3) y en el asiento va solo a IVA crédito 10/5 (F2): no se suma a
 * lo «no costo» que va a `IMPORTACION_ANTICIPO_IRE`.
 */
export const CODIGO_IVA_IMPORTACION = CONCEPTO_TRIBUTO_BY_FIELD.find((c) => c.field === 'iva_importacion_gs').codigo;

/** Concepto del precio en origen: sin proveedor, se acredita al proveedor del embarque. */
const CODIGO_FOB = 'FOB';

export interface ComponenteAsiento {
  id: string;
  /** Posición (base 1) en el orden en que la pantalla lista los componentes. */
  linea: number;
  concepto_codigo: string;
  proveedor_id: string | null;
  importe_gs: number;
}

export interface ContextoHaberDespacho {
  proveedorEmbarqueId: string;
  despachanteId: string | null;
  hayAnticipoDespacho: boolean;
  hayCuentaPuente: boolean;
}

export type LineaHaberDespacho =
  | { tipo: 'PROVEEDOR'; proveedor_id: string; monto: number; componentes: string[] }
  | { tipo: 'ANTICIPO_DESPACHO'; monto: number }
  | { tipo: 'DESPACHANTE'; proveedor_id: string; monto: number };

export interface ErrorHaberDespacho {
  codigo: 'COMPONENTE_SIN_PROVEEDOR' | 'TRIBUTOS_SIN_CONTRAPARTIDA';
  linea?: number;
  componente_id?: string;
}

const redondear = (n: number) => Math.round((n + Number.EPSILON) * 100) / 100;

/**
 * Agrupa el haber del asiento del despacho: una línea por proveedor (FOB sin proveedor -> el del embarque), y los tributos
 * sin proveedor a la contrapartida (anticipo de despacho con cuenta puente, o el despachante). Lo que no se puede asentar
 * se informa en `errores` y no arma líneas parciales de eso. Pura: la usan la vista previa, el asiento y la revisión.
 */
export function agruparHaberDespacho(
  componentes: ComponenteAsiento[],
  ctx: ContextoHaberDespacho,
): { haber: LineaHaberDespacho[]; errores: ErrorHaberDespacho[] } {
  const porProveedor = new Map<string, { monto: number; componentes: string[] }>();
  const errores: ErrorHaberDespacho[] = [];
  let tributos = 0;

  for (const comp of componentes) {
    if (!comp.importe_gs) continue; // importe 0: nada que acreditar (mercadería exenta, sin IVA)
    if (comp.proveedor_id) {
      sumar(porProveedor, comp.proveedor_id, comp);
    } else if (CODIGOS_TRIBUTO.includes(comp.concepto_codigo)) {
      tributos += comp.importe_gs;
    } else if (comp.concepto_codigo === CODIGO_FOB) {
      sumar(porProveedor, ctx.proveedorEmbarqueId, comp);
    } else {
      errores.push({ codigo: 'COMPONENTE_SIN_PROVEEDOR', linea: comp.linea, componente_id: comp.id });
    }
  }

  const haber: LineaHaberDespacho[] = [...porProveedor.entries()].map(([proveedor_id, v]) => ({
    tipo: 'PROVEEDOR' as const,
    proveedor_id,
    monto: redondear(v.monto),
    componentes: v.componentes,
  }));

  const totalTributos = redondear(tributos);
  if (totalTributos !== 0) {
    if (ctx.hayAnticipoDespacho && ctx.hayCuentaPuente) haber.push({ tipo: 'ANTICIPO_DESPACHO', monto: totalTributos });
    else if (ctx.despachanteId) haber.push({ tipo: 'DESPACHANTE', proveedor_id: ctx.despachanteId, monto: totalTributos });
    else errores.push({ codigo: 'TRIBUTOS_SIN_CONTRAPARTIDA' });
  }
  return { haber, errores };
}

function sumar(mapa: Map<string, { monto: number; componentes: string[] }>, proveedorId: string, comp: ComponenteAsiento) {
  const actual = mapa.get(proveedorId) ?? { monto: 0, componentes: [] };
  actual.monto += comp.importe_gs;
  actual.componentes.push(comp.id);
  mapa.set(proveedorId, actual);
}

/** Reparte el IVA del despacho entre la tasa del 10 % y la del 5 %. La parte al 5 % no puede superar el total. */
export function repartirIva(total: number, parte5: number): { iva10: number; iva5: number } {
  if (total < 0 || parte5 < 0 || parte5 > total) {
    throw errorImp(CODIGOS_IMP.IVA_5_SUPERA_TOTAL, 'La parte del IVA al 5 % no puede ser mayor que el IVA de importación total.', {
      campo: 'iva_importacion_5_gs',
    });
  }
  return { iva10: redondear(total - parte5), iva5: redondear(parte5) };
}
