#!  /usr/bin/node

var parser = require("./parse.js");
var cexps = require("./cexps.js");
var closures = require("./closure_conversion.js");
var desugar = require("./desugar.js");
var environments = require("./environments.js");
var errors = require("./errors.js");
var tokens = require("./tokenize.js");
var tools = require("./tools.js");
var typecheck = require("./typecheck.js");
var representation = require("./representation.js");
var _ = require("underscore");

var qc = require("quickcheck");
var assert = require("assert");


/* my own generators */

function arbIdentifier(construct) {
  var result = qc.arbString();
  if (_.size(result) > 0 &&
      tokens.isIdentifier(result[0])) {
    return new construct(result);
  }
  else {
    return arbIdentifier();
  }
}

function arbName() {
  return arbIdentifier(representation.Name);
}

function arbTypeOp() {
  return arbIdentifier(representation.TypeOp);
}

function arbArray(gen) {
  return qc.arbArray(gen);
}

function arbStrings() {
  return qc.arbArray(qc.arbString);
}


function arbPair(gen) {
  return function() {
    return [gen(), gen()];
  };
}

function arbArrayofPairs() {
  return arbArray(function() {
    return arbArray(arbPair(qc.arbString));
  });
}

function arbPairs() {
  return arbArray(arbPair(qc.arbString));
}


/* Tests for misc tools */
function emptyProp(xs) {
  return (tools.empty(xs) === tools.empty(xs) &&
          ((tools.empty(xs) === true) ||
           (tools.empty(xs) === false)));
}


function dictProp(pairs) {
  var dict = tools.dict(pairs);
  var result = _.map(pairs,
         function(pair) {
           if  ((_.size(pair) < 2) ||
               (_.size(pair[0]) < 1) ||
               (_.size(pair[1]) < 1)) {
                 return true;
               }
           return dict[pair[0]] === pair[1];
         });
  if (_.every(result, _.identity)) {
    return true;
  }
  return false;
}

function opMatchProp(strings) {
  var match = tools.opMatch(strings);
  var result = _.every(_.map(strings,
                     function (str) {
                       if (str.replace(/ /g,'').length < 1) {
                         return true;
                       }
                       var res = match(str);
                       if (res !== false) {
                         console.log(str);
                         return true;
                       }
                       return false;
                     }),
                       _.identity);
  return result;
}

function extendProp(pair) {
  if (pair.length < 2) {
    // empty lists or lists with one item are undefined
    // so just return true because extend can't handle them
    return true;
  }
  var x = _.first(pair);
  var y = _.first(_.rest(pair));
  var extended = tools.extend(x,y);
  return x.length + y.length === extended.length;
}

/* Tokenizer tests */


function toolsTests() {
  assert.equal(true, tools.empty([]));
  assert.equal(true, qc.forAll(dictProp, arbArrayofPairs));
  assert.equal(true, qc.forAll(extendProp, arbPairs));
  //assert.equal(true, qc.forAll(opMatchProp, arbStrings));
}


//toolsTests();
console.log(arbTypeOp());