import { words } from './data';
import { IBinaryTree, ITree } from '../../common';

function r() {
  return Math.random();
}

function rInt(end: number): number;
function rInt(start: number, end: number): number;
function rInt(start: number, end?: number): number {
  if (typeof end == 'number') {
    return ~~(Math.random() * (end - start) + start);
  } else {
    return ~~(Math.random() * start);
  }
}

function rString(): string {
  return words[rInt(words.length)];
}

function rArray<T>(fn: () => T, len: number): T[] {
  return new Array(len).fill(0).map(fn);
}

function rTable<T>(fn: () => T, h: number, w: number): T[][] {
  return new Array(h).fill(0).map(() => new Array(w).fill(0).map(fn));
}

function rBinaryTree<T>(fn: () => T, n: number): IBinaryTree<T> | null {
  if (n === 0) {
    return null;
  } else {
    const u = rInt(n);
    return {
      val: fn(),
      left: rBinaryTree(fn, u),
      right: rBinaryTree(fn, n - u - 1),
    };
  }
}

function rTree<T>(fn: () => T, n: number): ITree<T> | null {
  if (n === 0) {
    return null;
  } else if (n === 1) {
    return {
      val: fn(),
      childs: [],
    };
  }

  const l = rInt(Math.min(n - 1, 3)) + 1;
  const k = new Array(l).fill(1);
  n -= l + 1;

  while (n--) {
    k[rInt(l)]++;
  }

  return {
    val: fn(),
    childs: k.map(v => rTree(fn, v)!),
  };
}

function intArray(n: number, start: number = 0): number[] {
  const r = new Array(n);

  for (let i = 0; i < n; ++i, ++start) {
    r[i] = start;
  }

  for (let i = n - 1; i > 0; --i) {
    const j = rInt(i);
    [r[i], r[j]] = [r[j], r[i]];
  }

  return r;
}

export const rand = {
  int: rInt,
  string: rString,
  array: rArray,
  table: rTable,
  binaryTree: rBinaryTree,
  tree: rTree,
  intArray,
};