import type { Option } from "./option.ts";

export function first<T>(arr: readonly T[]): Option<T> {
  return arr[0] ?? null;
}

export function last<T>(arr: readonly T[]): Option<T> {
  return arr[arr.length - 1] ?? null;
}

export function at<T>(arr: readonly T[], index: number): Option<T> {
  if (index < 0) index = arr.length + index;
  return arr[index] ?? null;
}

export function find<T>(
  arr: readonly T[],
  predicate: (t: T) => boolean,
): Option<T> {
  return arr.find(predicate) ?? null;
}

export function findMap<T, U>(
  arr: readonly T[],
  fn: (t: T) => Option<U>,
): Option<U> {
  for (const item of arr) {
    const result = fn(item);
    if (result != null) return result;
  }
  return null;
}

export function findIndex<T>(
  arr: readonly T[],
  predicate: (t: T) => boolean,
): Option<number> {
  const index = arr.findIndex(predicate);
  return index >= 0 ? index : null;
}

export function partition<T>(
  arr: readonly T[],
  predicate: (t: T) => boolean,
): [T[], T[]] {
  const pass: T[] = [];
  const fail: T[] = [];
  for (const item of arr) {
    if (predicate(item)) {
      pass.push(item);
    } else {
      fail.push(item);
    }
  }
  return [pass, fail];
}

export function groupBy<T, K extends string | number>(
  arr: readonly T[],
  keyFn: (t: T) => K,
): Record<K, T[]> {
  const result = {} as Record<K, T[]>;
  for (const item of arr) {
    const key = keyFn(item);
    if (!result[key]) {
      result[key] = [];
    }
    result[key].push(item);
  }
  return result;
}

export function unique<T>(arr: readonly T[]): T[] {
  return [...new Set(arr)];
}

export function uniqueBy<T, K>(arr: readonly T[], keyFn: (t: T) => K): T[] {
  const seen = new Set<K>();
  const result: T[] = [];
  for (const item of arr) {
    const key = keyFn(item);
    if (!seen.has(key)) {
      seen.add(key);
      result.push(item);
    }
  }
  return result;
}

export function sortBy<T>(
  arr: readonly T[],
  keyFn: (t: T) => number | string,
): T[] {
  return [...arr].sort((a, b) => {
    const ka = keyFn(a);
    const kb = keyFn(b);
    if (ka < kb) return -1;
    if (ka > kb) return 1;
    return 0;
  });
}

export function sortByDesc<T>(
  arr: readonly T[],
  keyFn: (t: T) => number | string,
): T[] {
  return [...arr].sort((a, b) => {
    const ka = keyFn(a);
    const kb = keyFn(b);
    if (ka > kb) return -1;
    if (ka < kb) return 1;
    return 0;
  });
}

export function chunk<T>(arr: readonly T[], size: number): T[][] {
  const result: T[][] = [];
  for (let i = 0; i < arr.length; i += size) {
    result.push(arr.slice(i, i + size));
  }
  return result;
}

export function zip<T, U>(a: readonly T[], b: readonly U[]): [T, U][] {
  const length = Math.min(a.length, b.length);
  const result: [T, U][] = [];
  for (let i = 0; i < length; i++) {
    result.push([a[i], b[i]]);
  }
  return result;
}

export function zipWith<T, U, R>(
  a: readonly T[],
  b: readonly U[],
  fn: (t: T, u: U) => R,
): R[] {
  const length = Math.min(a.length, b.length);
  const result: R[] = [];
  for (let i = 0; i < length; i++) {
    result.push(fn(a[i], b[i]));
  }
  return result;
}

export function intersperse<T>(arr: readonly T[], separator: T): T[] {
  if (arr.length <= 1) return [...arr];
  const result: T[] = [arr[0]];
  for (let i = 1; i < arr.length; i++) {
    result.push(separator, arr[i]);
  }
  return result;
}

export function range(start: number, end: number): number[] {
  const result: number[] = [];
  for (let i = start; i < end; i++) {
    result.push(i);
  }
  return result;
}

export function isEmpty<T>(arr: readonly T[]): boolean {
  return arr.length === 0;
}

export function isNonEmpty<T>(arr: readonly T[]): arr is [T, ...T[]] {
  return arr.length > 0;
}

export function sum(arr: readonly number[]): number {
  return arr.reduce((acc, n) => acc + n, 0);
}

export function sumBy<T>(arr: readonly T[], fn: (t: T) => number): number {
  return arr.reduce((acc, t) => acc + fn(t), 0);
}

export function maxBy<T>(arr: readonly T[], fn: (t: T) => number): Option<T> {
  if (arr.length === 0) return null;
  let max = arr[0];
  let maxValue = fn(max);
  for (let i = 1; i < arr.length; i++) {
    const value = fn(arr[i]);
    if (value > maxValue) {
      max = arr[i];
      maxValue = value;
    }
  }
  return max;
}

export function minBy<T>(arr: readonly T[], fn: (t: T) => number): Option<T> {
  if (arr.length === 0) return null;
  let min = arr[0];
  let minValue = fn(min);
  for (let i = 1; i < arr.length; i++) {
    const value = fn(arr[i]);
    if (value < minValue) {
      min = arr[i];
      minValue = value;
    }
  }
  return min;
}