import Prando from "prando";

type Result = 'OK' | 'Falsified' | 'Exception';

type ShrinkResult<A> = { counterexample: A, shrinks: number };

type TestResult<A> = {
  result: Result,
  counterexample: ShrinkResult<A> | null
};

type Predicate<A> = (a: A) => boolean;

export type Gen<A> = (rng: Prando) => ((size: number) => A);

type Shrinker<A> = (a: A) => A[];

type Property<A> = (rng: Prando,
                    size: number) =>  TestResult<A>;

const MAX_SUCCESS = 100;

function findMinimalCounterExample<A>(x: A,
  predicate: Predicate<A>,
  shrinker: Shrinker<A>,
  depth: number = 0): ShrinkResult<A> {
  let xs = shrinker(x);
  let counterexample = x;
  let shrinks = depth;
  for (let y of xs) {
    if (!predicate(y)) {
      let shrink = findMinimalCounterExample(y, predicate, shrinker, depth + 1);
      if (shrink.shrinks > depth) {
        counterexample = shrink.counterexample;
        shrinks = shrink.shrinks;
      }
    }
  }
  return { counterexample, shrinks };
}


export function generate<A>(gen: Gen<A>): A {
  let rng = new Prando(Math.random() * 1000);
  return gen(rng)(100);
}

export function property<A>(
  predicate: Predicate<A>,
  generator: Gen<A>,
  shrinker: Shrinker<A>): Property<A> {
  return (rng: Prando,
          size: number) => {
            let gen = generator(rng);
            let i = 0;
            for (; i < MAX_SUCCESS; i++) {
              let x = gen(size);
              if (!predicate(x)) {
                let counterexample = findMinimalCounterExample(x, predicate, shrinker);
                return { result: 'Falsified', tests: i+1, counterexample };
              }
              size++;
            }
            return { result: 'OK', tests: i, counterexample: null };
          };
}

// basic generators

export function listOf<A>(gen: Gen<A>): Gen<A[]> {
  return (rng: Prando) => {
    let g = gen(rng);
    return (size: number) => {
      let result = [];
      for (let i = 0; i < size; i++) {
        result.push(g(size));
      }
      return result;
    };
  };
}

export function shrinklist<A>(arr: A[]): A[][] {
  let result = [];

  let tail = arr.slice(1);
  let keep1 = arr.slice();
  keep1.splice(1, 1);
  result.push(tail,keep1);

  if (arr.length >3) {
    let half = Math.floor(arr.length / 2);
    let copy = arr.slice();
    let secondHalf = copy.slice(half);
    result.push(secondHalf);
  }

  return result;
}

export let someInt : Gen<number> = (rng: Prando) =>
  (size: number) =>
    rng.nextInt(-size, size);