export function iota(count, start = 0) {
  const result = [];
  for (let x = 0; x < count; x++) {
    result.push(start + x);
  }
  return result;
}

export function over(f, ...args) {
  return function (list) {
    return list.map((v) => f(v, ...args));
  };
}

/**
 * @param {((...args: any[]) => any)[]} funs
 */
export function juxt(...funs) {
  return function (/** @type {any[]} */ ...args) {
    return funs.map((fun) => fun(...args));
  };
}

export function compose(...funs) {
  funs = funs.slice();
  return function (...args) {
    let result = funs.pop()(...args);
    while (funs.length > 0) {
      result = funs.pop()(result);
    }
    return result;
  };
}

export function on(fun, key_fun) {
  return function (data) {
    return fun(key_fun(data));
  };
}

export function applying(f, ...pos_args) {
  return function (list) {
    return f(...pos_args, ...list);
  };
}

export function filter(f, ...args) {
  return function (list) {
    return list.filter((v) => f(v, ...args));
  };
}

export function zip_with(f) {
  return function (lists) {
    const result = [];
    outer: for (let idx = 0; ; idx++) {
      const args = [];
      for (let list of lists) {
        if (idx < list.length) {
          args.push(list[idx]);
        } else {
          break outer;
        }
      }
      result.push(f(...args));
    }
    return result;
  };
}

export function element(key) {
  return function (it) {
    return it[key];
  };
}

export function eq(v, eq) {
  if (eq !== undefined) {
    return function (w) {
      return eq(v, w);
    };
  } else {
    return function (w) {
      return v === w;
    };
  }
}

/**
 * @template T, U
 * @param { (args: T[]) => boolean} cond
 * @param {(args: T[]) => U} fn
 */
export function applicable_when(cond, fn) {
  return function (/** @type {T} */ data) {
    if (cond(data)) {
      return fn(data);
    } else {
      return data;
    }
  };
}

/**
 * @param {{ test: (arg0: any) => any; }} regex
 */
export function matches_regex(regex) {
  return function (string) {
    return regex.test(string);
  };
}

//TODO: handle maps, at least

/**
 * @param {string | number | symbol} key
 */
export function key(key) {
  return function (it) {
    return it[key];
  };
}

/**
 * @param {(...args: any[]) => boolean} fun
 */
export function complement(fun) {
  return function (...args) {
    return !fun(...args);
  };
}

/**
 * @param {(a: any) => boolean} pred
 */
export function include(pred) {
  return function (seq) {
    return seq.filter(pred);
  };
}

/**
 * @param {(a: any, b: any) => boolean} pred
 */
export function exclude(pred) {
  const negated = complement(pred);
  return function (seq) {
    return seq.filter(negated);
  };
}

/**
 * @param {{ [x: string]: any }} keyed
 */
export function pick(keyed) {
  return function (keys) {
    return keys.map((key) => keyed[key]);
  };
}

/**
 * @param {(arg0: any, arg1: any) => any} comparator
 * @param {(arg0: any) => any} key
 */
export function sorted(comparator, key) {
  if (key) {
    return function (seq) {
      const result = seq.slice();
      result.sort((a, b) => {
        return comparator(key(a), key(b)) ? -1 : 1;
      });
      return result;
    };
  } else {
    return function (seq) {
      const result = seq.slice();
      result.sort((a, b) => {
        return comparator(a, b) ? -1 : 1;
      });
      return result;
    };
  }
}

function matching_list_reducer(test, acc, next) {
  let result;
  if (acc && acc[0] && test(acc[0][0], next[0])) {
    result = [
      [acc[0][0], ...[...acc[0].slice(1), ...next.slice(1)]],
      ...acc.slice(1),
    ];
  } else {
    result = [next, ...(acc || [])];
  }
  return result;
}

export function combine_matching_lists({ test = (a, b) => a === b } = {}) {
  return function (acc, next) {
    return matching_list_reducer(test, acc, next);
  };
}

export function cons_new({ test = (a, b) => a === b, key = (v) => v } = {}) {
  return function (acc, next) {
    if (acc && test(key(acc[0]), key(next))) {
      return acc;
    } else {
      return [next, ...acc];
    }
  };
}

/**
 * @param {{ collector?: ({ test, key }?: { test?: (a: any, b: any) => boolean; key?: (v: any) => any; }) => (acc: any, next: any) => any; test: any; key: any; }} [it]
 */
export function compress_runs({ collector = cons_new, test, key } = {}) {
  return function (/** @type {any[]} */ it) {
    return it.reduce(collector({ test, key }), []).reverse();
  };
}

/**
 * @param {number} n
 */
export function slice(n) {
  return function (/** @type {string | any[]} */ seq) {
    return seq.slice(n);
  };
}

/**
 * @param {(arg0: any[]) => any} transform
 */
export function transform_tail(transform) {
  return function ([head, ...tail]) {
    const newTail = transform(tail);
    return [
      head,
      ...(Object.hasOwnProperty.call(newTail, "length") ? newTail : [newTail]),
    ];
  };
}