/**
 * Modern array utilities leveraging ES2024 features
 */

/**
 * Group array items by a key using ES2024 Object.groupBy
 * This is more efficient than manual grouping
 */
export function groupBy<T, K extends PropertyKey>(
  array: T[],
  keyFn: (item: T) => K
): Record<K, T[]> {
  // Use native Object.groupBy if available (ES2024)
  if ('groupBy' in Object) {
    return (Object as any).groupBy(array, keyFn);
  }
  
  // Fallback polyfill
  return array.reduce((groups, item) => {
    const key = keyFn(item);
    if (!groups[key]) {
      groups[key] = [];
    }
    groups[key].push(item);
    return groups;
  }, {} as Record<K, T[]>);
}

/**
 * Chunk array into smaller arrays of specified size
 * Uses modern array methods for efficiency
 */
export function chunk<T>(array: T[], size: number): T[][] {
  if (size <= 0) return [];
  
  const chunks: T[][] = [];
  for (let i = 0; i < array.length; i += size) {
    chunks.push(array.slice(i, i + size));
  }
  return chunks;
}

/**
 * Get unique items from array with optional key function
 * Leverages Set for better performance
 */
export function unique<T>(array: T[]): T[];
export function unique<T, K>(array: T[], keyFn: (item: T) => K): T[];
export function unique<T, K>(array: T[], keyFn?: (item: T) => K): T[] {
  if (!keyFn) {
    return [...new Set(array)];
  }
  
  const seen = new Set<K>();
  return array.filter(item => {
    const key = keyFn(item);
    if (seen.has(key)) {
      return false;
    }
    seen.add(key);
    return true;
  });
}

/**
 * Safe array access using ES2024 .at() method
 * Returns undefined for out-of-bounds access
 */
export function safeAt<T>(array: T[], index: number): T | undefined {
  return array.at?.(index) ?? array[index];
}

/**
 * Partition array into two arrays based on predicate
 */
export function partition<T>(
  array: T[], 
  predicate: (item: T) => boolean
): [T[], T[]] {
  const truthy: T[] = [];
  const falsy: T[] = [];
  
  for (const item of array) {
    if (predicate(item)) {
      truthy.push(item);
    } else {
      falsy.push(item);
    }
  }
  
  return [truthy, falsy];
}

/**
 * Modern intersection of arrays
 */
export function intersection<T>(...arrays: T[][]): T[] {
  if (arrays.length === 0) return [];
  if (arrays.length === 1) return [...arrays[0]];
  
  const [first, ...rest] = arrays;
  const sets = rest.map(arr => new Set(arr));
  
  return first.filter(item => sets.every(set => set.has(item)));
}

/**
 * Safe array operations that return null on empty arrays
 */
export const SafeArray = {
  first: <T>(array: T[]): T | null => array[0] ?? null,
  last: <T>(array: T[]): T | null => array.at?.(-1) ?? array[array.length - 1] ?? null,
  random: <T>(array: T[]): T | null => {
    if (array.length === 0) return null;
    return array[Math.floor(Math.random() * array.length)];
  }
} as const;