var q = require('q');
var extend = require('deep-extend');
var probe = require('./aproba-overload');

module.exports = {
  _compileOptions: {
    engine: null,
    template: null,
    data: null
  },
  _compile: function (options, callback) {
    var d = q.defer();

    // Do compile and resolve/reject promise

    return d.promise.nodeify(callback);
  },

  /**
   * Compile template
   * 
   * @param {String|Object} template   Either template name or options object
   * @param {Object}        [data]     data for template rendering
   * @param {Object}        [options]  optional object for options
   * @param {Function}      [callback] optional callback, returns promise of null
   * 
   * @return {q.Promise|null} promise if no callback, null if returned.
   */
  compile: function (template, data, options, callback) {
    var args = arguments;
    var opts = extend({}, module.exports._compileOptions);


    if (probe('O|OF', args)) { // Options with optional callback
      extend(opts, args[0]);
      callback = args[1];
    } else if (probe('SO|SOF', args)) { // template name and data, optional callback
      opts.template = args[0];
      opts.data = args[1];
      callback = args[2];
    } else if (probe('SOO|SOOF', args)) { // template name and data, additional template options, optional callback
      extend(opts, args[2]);
      opts.template = args[0];
      opts.data = args[1];
      callback = args[3];
    } else {
      throw new Error('Invalid Arguments'); // need more descriptive error message.
    }

    return module.exports._compile(opts, callback);
  }
};

/**
 * Filename: aproba-overload.js
 * Created by rhett on 2/22/16.
 */
'use strict';
var aproba = require('aproba');

var validate = module.exports = function (schema, args, throwErr) {

  // Enable OR syntax
  if (/.+\|.+/.test(schema)) {  // example schema = 'O|OF|O*F'
    var t = schema.split(/\|(.+)/); // t = ['O', 'OF|O*F', '']

    // return recursive for schema = 'O' OR recursive for schema = 'OF|O*F' <= which has another recurse
    return validate(t[0], args, throwErr) || validate(t[1], args, throwErr);
    // Todo: problem with throwErr here; If true passed it may not reach second call. Rethink this combo
  }

  try {
    aproba(schema, args);
  } catch (err) {
    if (!throwErr &&      // pass-through requested
      [
        'EMISSINGARG',
        'EUNKNOWNTYPE',
        'EINVALIDTYPE',
        'ETOOMANYARGS'
      ].indexOf(err.code) // Catch only known errors
    ) {
      return false;       // Doesn't meet schema
    } else {
      throw err;          // pass-through or other, unexpected error
    }
  }

  return true; // no problems, success
};