;(function () {

'use strict';
/*jshint laxbreak: true,  browser:true */
/*global define*/

var esprima
  , exportFn
  , toString = Object.prototype.toString
  ;

if (typeof module === 'object' && typeof module.exports === 'object' && typeof require === 'function') {
  // server side
  esprima = require('esprima');
  exportFn = function (redeyed) { module.exports = redeyed; };
  bootstrap(esprima, exportFn);
} else if (typeof define === 'function' && define.amd) {
  // client side
  // amd
  define(['esprima'], function (esprima) {
      return bootstrap(esprima);
  });
} else if (typeof window === 'object') {
  // no amd -> attach to window if it exists
  // Note that this requires 'esprima' to be defined on the window, so that script has to be loaded first
  window.redeyed = bootstrap(window.esprima);
}

function bootstrap(esprima, exportFn) {

  function isFunction (obj) {
    return toString.call(obj) === '[object Function]';
  }

  function isString (obj) {
    return toString.call(obj) === '[object String]';
  }

  function isNumber (obj) {
    return toString.call(obj) === '[object Number]';
  }

  function isObject (obj) {
    return toString.call(obj) === '[object Object]';
  }

  function surroundWith (before, after) {
    return function (s) { return before + s + after; };
  }

  function isNonCircular(key) { 
    return key !== '_parent'; 
  }

  function objectizeString (value) {
    var vals = value.split(':');

    if (0 === vals.length || vals.length > 2) 
      throw new Error(
        'illegal string config: ' + value +
        '\nShould be of format "before:after"'
      );

    if (vals.length === 1 || vals[1].length === 0) {
      return vals.indexOf(':') < 0 ? { _before: vals[0] } : { _after: vals[0] };
    } else {
      return { _before: vals[0], _after: vals[1] };
    }
  }

  function objectize (node) {

    // Converts 'bef:aft' to { _before: bef, _after: aft } 
    // and resolves undefined before/after from parent or root

    function resolve (value, key) {
      // resolve before/after from root or parent if it isn't present on the current node
      if (!value._parent) return undefined;
      
      // Immediate parent
      if (value._parent._default && value._parent._default[key]) return value._parent._default[key];

      // Root
      var root = value._parent._parent;
      if (!root) return undefined;

      return root._default ? root._default[key] : undefined;
    }

    function process (key) {
      var value = node[key];

      if (!value) return;
      if (isFunction(value)) return;

      // normalize all strings to objects
      if (isString(value)) {
        node[key] = value = objectizeString(value);
      }
      
      value._parent = node;
      if (isObject(value)) {
        if (!value._before && !value._after) return objectize (value);

        // resolve missing _before or _after from parent(s) 
        // in case we only have either one on this node
        value._before =  value._before || resolve(value, '_before');
        value._after  =  value._after  || resolve(value, '_after');
        
        return;
      } 

      throw new Error('nodes need to be either {String}, {Object} or {Function}.' + value + ' is neither.');
    }

    // Process _default ones first so children can resolve missing before/after from them
    if (node._default) process('_default');

    Object.keys(node)
      .filter(function (key) {
        return isNonCircular(key) 
          && node.hasOwnProperty(key)
          && key !== '_before' 
          && key !== '_after' 
          && key !== '_default';
      })
      .forEach(process);
  }

  function functionize (node) {
    Object.keys(node)
      .filter(function (key) { 
        return isNonCircular(key) && node.hasOwnProperty(key);
      })
      .forEach(function (key) {
        var value = node[key];

        if (isFunction(value)) return;

        if (isObject(value)) {

          if (!value._before && !value._after) return functionize(value);

          // at this point before/after were "inherited" from the parent or root
          // (see objectize)
          var before = value._before || '';
          var after = value._after || '';

          node[key] = surroundWith (before, after);
          return node[key];
        }
      });
  }

  function normalize (root) {
    objectize(root);
    functionize(root);
  }

  function mergeTokensAndComments(tokens, comments) {
    var all = {};

    function addToAllByRangeStart(t) { all[ t.range[0] ] = t; }

    tokens.forEach(addToAllByRangeStart);
    comments.forEach(addToAllByRangeStart);

    // keys are sorted automatically
    return Object.keys(all)
      .map(function (k) { return all[k]; });
  }

  function redeyed (code, config, opts) {
    opts = opts || {};
    var parser = opts.parser || esprima;
    var buildAst = !!opts.buildAst;

    var hashbang =  ''
      , ast
      , tokens
      , comments
      , lastSplitEnd = 0
      , splits = []
      , transformedCode
      , all
      , info
      ;

    // Replace hashbang line with empty whitespaces to preserve token locations
    if (code[0] === '#' && code[1] === '!') {
      hashbang = code.substr(0, code.indexOf('\n') + 1);
      code = Array.apply(0, Array(hashbang.length)).join(' ') + '\n' + code.substr(hashbang.length);
    }

    if (buildAst) {
      ast = parser.parse(code, { tokens: true, comment: true, range: true, tolerant: true });
      tokens = ast.tokens;
      comments = ast.comments;
    } else {
      tokens = [];
      comments = [];
      parser.tokenize(code, { range: true, comment: true }, function (token) {
        if (token.type === 'LineComment') {
          token.type = 'Line';
          comments.push(token)
        } else if (token.type === 'BlockComment') {
          token.type = 'Block';
          comments.push(token)
        } else {
          // Optimistically upgrade 'static' to a keyword
          if (token.type === 'Identifier' && token.value === 'static') token.type = 'Keyword';
          tokens.push(token);
        }
      });
    }

    normalize(config);

    function tokenIndex(tokens, tkn, start) {
      var current
        , rangeStart = tkn.range[0];

      for (current = start; current < tokens.length; current++) {
        if (tokens[current].range[0] === rangeStart) return current;
      }

      throw new Error('Token %s not found at or after index: %d', tkn, start);
    }

    function process(surround) {
      var result
        , currentIndex
        , nextIndex
        , skip = 0
        , splitEnd
        ;

      result = surround(code.slice(start, end), info);
      if (isObject(result)) {
        splits.push(result.replacement);

        currentIndex =  info.tokenIndex;
        nextIndex    =  tokenIndex(info.tokens, result.skipPastToken, currentIndex);
        skip         =  nextIndex - currentIndex;
        splitEnd     =  skip > 0 ? tokens[nextIndex - 1].range[1] : end;
      } else {
        splits.push(result);
        splitEnd = end;
      }

      return { skip: skip, splitEnd: splitEnd  };
    }

    function addSplit (start, end, surround, info) {
      var result
        , nextIndex
        , skip = 0
        ;

      if (start >= end) return;
      if (surround) {
        result       =  process(surround);
        skip         =  result.skip;
        lastSplitEnd =  result.splitEnd;
      } else {
        splits.push(code.slice(start, end));
        lastSplitEnd = end;
      }

      return skip;
    }

    all = mergeTokensAndComments(tokens, comments);
    for (var tokenIdx = 0; tokenIdx < all.length; tokenIdx++) {
      var token = all[tokenIdx]
        , surroundForType = config[token.type]
        , surround
        , start
        , end;
      
      // At least the type (e.g., 'Keyword') needs to be specified for the token to be surrounded
      if (surroundForType) {

        // root defaults are only taken into account while resolving before/after otherwise
        // a root default would apply to everything, even if no type default was specified
        surround = surroundForType 
          && surroundForType.hasOwnProperty(token.value) 
          && surroundForType[token.value]
          && isFunction(surroundForType[token.value])
            ? surroundForType[token.value] 
            : surroundForType._default;

        start = token.range[0];
        end = token.range[1];

        addSplit(lastSplitEnd, start);
        info = { tokenIndex: tokenIdx, tokens: all, ast: ast, code: code };
        tokenIdx += addSplit(start, end, surround, info);
      }
    }

    if (lastSplitEnd < code.length) {
      addSplit(lastSplitEnd, code.length);
    }

  if (!opts.nojoin) {
    transformedCode = splits.join('');
    if (hashbang.length > 0) {
      transformedCode = hashbang + transformedCode.substr(hashbang.length);
    }
  }

    return {
        ast      :  ast
      , tokens   :  tokens
      , comments :  comments
      , splits   :  splits
      , code     :  transformedCode
    };
  }

  return exportFn ? exportFn(redeyed) : redeyed;
}
})();