// Copyright (c) Meta Platforms, Inc. and affiliates.

/**
 * @file computeOverflow.ts
 * @input Plain measurements (item widths, gap, available width, indicator width, limits)
 * @output Pure overflow computation: how many items are visible and their row layout
 * @position Pure helper consumed by useOverflow; contains no DOM or React code so the
 *           fit/clamp math and the multi-row packing can be unit-tested in isolation.
 *
 * There is a single source of truth for `visibleCount`:
 *   visibleCount = clamp(fitCount, minVisibleItems, maxVisibleItems ?? itemCount)
 *
 * SYNC: When modified, update:
 * - /packages/core/src/hooks/useOverflow.ts (the only caller)
 */

export interface ComputeOverflowInput {
  /** Measured widths of each item, in original DOM order. */
  widths: number[];
  /** Gap between items, in pixels. */
  gap: number;
  /** Width available to lay items out, in pixels. */
  availableWidth: number;
  /** Measured width of the overflow indicator (0 if none). */
  indicatorWidth: number;
  /** Floor — always show at least this many items. */
  minVisibleItems: number;
  /** Ceiling — never show more than this many items. `undefined` = no cap. */
  maxVisibleItems?: number;
  /**
   * Bounded multi-row: wrap items across up to this many rows, then collapse
   * the rest into the overflow indicator. `undefined` (or `1`) = single line.
   */
  maxRows?: number;
  /** Which end items collapse from. */
  collapseFrom: 'start' | 'end';
}
export interface ComputeOverflowResult {
  /** Number of items that should be rendered in the visible container. */
  visibleCount: number;
  /** Number of rows the visible items occupy (always 1 for the single-line path). */
  rows: number;
}
function clamp(value: number, min: number, max: number): number {
  return Math.max(Math.min(value, max), min);
}

/**
 * Resolve the ceiling and floor into a single [floor, ceiling] pair.
 *
 * `maxVisibleItems` is clamped to `itemCount` (a cap larger than the list is a
 * no-op). When `maxVisibleItems < minVisibleItems`, the floor wins (D1) via the
 * final clamp — the hook is responsible for the dev-only warning.
 */
function resolveBounds(itemCount: number, minVisibleItems: number, maxVisibleItems: number | undefined): {
  floor: number;
  ceiling: number;
} {
  const floor = Math.max(0, Math.min(minVisibleItems, itemCount));
  const rawCeiling = maxVisibleItems == null ? itemCount : maxVisibleItems;
  const ceiling = Math.max(0, Math.min(rawCeiling, itemCount));
  return {
    floor,
    ceiling
  };
}

/**
 * Single-line greedy fit: how many items fit in one row of `availableWidth`,
 * reserving indicator space for every non-final admitted item. Mirrors the
 * original in-hook loop so single-line behavior is unchanged.
 */
function computeSingleLineFit(orderedWidths: number[], gap: number, availableWidth: number, indicatorWidth: number, floor: number, ceiling: number): number {
  let totalWidth = 0;
  let count = 0;
  for (let i = 0; i < orderedWidths.length; i++) {
    if (count >= ceiling) {
      break;
    }
    const itemWidth = orderedWidths[i];
    const gapWidth = i > 0 ? gap : 0;
    const candidateWidth = totalWidth + itemWidth + gapWidth;
    const isLastItem = i === orderedWidths.length - 1;
    const reservedWidth = isLastItem ? 0 : indicatorWidth + (count > 0 || indicatorWidth > 0 ? gap : 0);
    if (candidateWidth + reservedWidth > availableWidth && count >= floor) {
      break;
    }
    totalWidth = candidateWidth;
    count++;
  }
  return count;
}

/**
 * Pack items into rows, wrapping when the next item would exceed
 * `availableWidth`. On the last allowed row, keep `indicatorReserve` px free so
 * the overflow indicator fits. Stops admitting once no further item can be
 * placed within `maxRows`.
 */
function packRows(orderedWidths: number[], gap: number, availableWidth: number, indicatorReserve: number, maxRows: number): {
  placed: number;
  rows: number;
} {
  let placed = 0;
  let row = 1;
  let rowWidth = 0;
  for (let i = 0; i < orderedWidths.length; i++) {
    const w = orderedWidths[i];
    const isFirstInRow = rowWidth === 0;
    const candidate = isFirstInRow ? w : rowWidth + gap + w;
    const onLastRow = row === maxRows;
    const reserve = onLastRow && indicatorReserve > 0 ? indicatorReserve + gap : 0;
    if (candidate + reserve <= availableWidth) {
      rowWidth = candidate;
      placed++;
      continue;
    }
    if (isFirstInRow) {
      // A single item wider than the row occupies this row alone (it will be
      // clipped visually). But if it can't coexist with the reserved indicator
      // on the last row, stop here.
      if (onLastRow && reserve > 0) {
        break;
      }
      rowWidth = candidate;
      placed++;
      continue;
    }
    if (row >= maxRows) {
      break;
    }
    row++;
    rowWidth = 0;
    i--; // re-attempt this item as the first on the new row
  }
  return {
    placed,
    rows: row
  };
}

/** Count how many rows a set of items occupies when wrapped at availableWidth. */
function countRows(orderedWidths: number[], gap: number, availableWidth: number): number {
  if (orderedWidths.length === 0) {
    return 0;
  }
  let rows = 1;
  let rowWidth = 0;
  for (let i = 0; i < orderedWidths.length; i++) {
    const w = orderedWidths[i];
    const isFirstInRow = rowWidth === 0;
    const candidate = isFirstInRow ? w : rowWidth + gap + w;
    if (candidate <= availableWidth || isFirstInRow) {
      rowWidth = candidate;
    } else {
      rows++;
      rowWidth = w;
    }
  }
  return rows;
}

/**
 * Multi-row packing (Strategy A): simulate wrapping items into rows of
 * `availableWidth`, admitting items until a new item would require a row beyond
 * `maxRows`, reserving indicator space on the final row when items overflow.
 * Returns the admitted count and how many rows those items occupy. Assumes
 * uniform row height.
 */
function computeMultiRowFit(orderedWidths: number[], gap: number, availableWidth: number, indicatorWidth: number, maxRows: number): {
  count: number;
  rows: number;
} {
  const n = orderedWidths.length;
  if (n === 0) {
    return {
      count: 0,
      rows: 0
    };
  }

  // If everything fits within maxRows without reserving indicator space, there
  // is no overflow and no indicator is needed.
  const packAll = packRows(orderedWidths, gap, availableWidth, 0, maxRows);
  if (packAll.placed === n) {
    return {
      count: n,
      rows: packAll.rows
    };
  }

  // Overflow → reserve indicator space on the final row and re-pack.
  const packWithIndicator = packRows(orderedWidths, gap, availableWidth, indicatorWidth, maxRows);
  const count = packWithIndicator.placed;
  const rows = countRows(orderedWidths.slice(0, count), gap, availableWidth);
  return {
    count,
    rows: Math.max(count > 0 ? 1 : 0, rows)
  };
}

/**
 * Pure overflow computation. Given plain measurements and the configured
 * limits, return how many items should be visible and how many rows they
 * occupy. No DOM, no React — safe to unit-test directly.
 */
export function computeOverflow(input: ComputeOverflowInput): ComputeOverflowResult {
  const {
    widths,
    gap,
    availableWidth,
    indicatorWidth,
    minVisibleItems,
    maxVisibleItems,
    maxRows,
    collapseFrom
  } = input;
  const itemCount = widths.length;
  if (itemCount === 0) {
    return {
      visibleCount: 0,
      rows: 0
    };
  }
  const {
    floor,
    ceiling
  } = resolveBounds(itemCount, minVisibleItems, maxVisibleItems);
  const orderedWidths = collapseFrom === 'end' ? widths : [...widths].reverse();
  const multiRow = maxRows != null && maxRows > 1;
  if (!multiRow) {
    const fitCount = computeSingleLineFit(orderedWidths, gap, availableWidth, indicatorWidth, floor, ceiling);
    const visibleCount = clamp(fitCount, floor, ceiling);
    return {
      visibleCount,
      rows: visibleCount > 0 ? 1 : 0
    };
  }
  const {
    count,
    rows
  } = computeMultiRowFit(orderedWidths, gap, availableWidth, indicatorWidth, maxRows);
  const visibleCount = clamp(count, floor, ceiling);
  const resolvedRows = visibleCount === count ? rows : countRows(orderedWidths.slice(0, visibleCount), gap, availableWidth);
  return {
    visibleCount,
    rows: visibleCount > 0 ? Math.max(1, resolvedRows) : 0
  };
}