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)) {
      console.log("Shrinking with " + 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, counterexample };
              }
              size++;
            }
            return { result: 'OK', tests: i, counterexample: null };
          };
}