var git = require('../'),
    Tree = git.Tree,
    events = require('events'),
    path = require('path');

var oldEntryByIndex = Tree.prototype.entryByIndex,
    oldEntryByName = Tree.prototype.entryByName,
    oldGetEntry = Tree.prototype.getEntry;

/**
 * Diff two trees
 * @param {Tree} tree to diff against
 * @param {Function} callback
 * @return {DiffList}
 */
Tree.prototype.diff = function(that, callback) {
  this.diffTree(this.repo, that, null, callback);
};

/**
 * Get an entry at the ith position.
 *
 * @param {Number} i
 * @return {TreeEntry}
 */
Tree.prototype.entryByIndex = function(i) {
  var entry = oldEntryByIndex.call(this, i);
  entry.parent = this;
  return entry;
};

/**
 * Get an entry by name; if the tree is a directory, the name is the filename.
 *
 * @param {String} name
 * @return {TreeEntry}
 */
Tree.prototype.entryByName = function(name) {
  var entry = oldEntryByName.call(this, name);
  entry.parent = this;
  return entry;
};

/**
 * Get an entry at a path. Unlike by name, this takes a fully
 * qualified path, like `/foo/bar/baz.javascript`
 *
 * @param {String} path
 * @return {TreeEntry}
 */
Tree.prototype.getEntry = function(path, callback) {
  // FIXME: this method ought to implement the recursion directly, rather than
  // rely on oldGetEntry, in order to ensure that `parent` pointers are direct.
  var self = this;
  oldGetEntry.call(this, path, function(error, entry) {
    if (error) return callback(error);

    entry.parent = self;
    entry.path = function() { return path };
    callback(null, entry);
  });
};

/**
 * Return an array of the entries in this tree (excluding its children).
 * @return {[TreeEntry]} an array of TreeEntrys
 */
Tree.prototype.entries = function() {
  var size = this.size(),
      result = [];
  for (var i = 0; i < size; i++) {
    result.push(this.entryByIndex(i));
  }
  return result;
};

/**
 * Recursively walk the tree in breadth-first order. Fires an event for each entry.
 *
 * @fires Tree#entry
 * @fires Tree#end
 *
 * @param {Boolean} [blobsOnly = true] True to emit only blob & blob executable entries.
 *
 * @return {EventEmitter}
 */
Tree.prototype.walk = function(blobsOnly) {
  if (typeof blobsOnly == 'undefined') blobsOnly = true;

  var self = this,
      event = new events.EventEmitter(),
      entries = [],
      errors = [];

  var total = 1;

  // This looks like a DFS, but it is a BFS because of implicit queueing in
  // the recursive call to `entry.getTree(bfs)`
  function bfs(error, tree) {
    total--;
    if (error) return errors.push(error);

    tree.entries().forEach(function (entry) {
      if (!blobsOnly || entry.isFile()) {
        event.emit('entry', entry);
        entries.push(entry);
      }

      if (entry.isTree()) {
        total++;
        entry.getTree(bfs);
      }
    });
    if (total === 0)
      event.emit('end', errors.length ? errors : null, entries);
  }

  event.start = function() {
    bfs(null, self);
  };

  return event;
};

/**
 * Return the path of this tree, like `/lib/foo/bar`
 * @return {String}
 */
Tree.prototype.path = function(blobsOnly) {
  return this.entry ? this.entry.path() : '';
};

/**
 * Make builder. This is helpful for modifying trees.
 * @return {TreeBuilder}
 */
var oldBuilder = Tree.prototype.builder;
Tree.prototype.builder = function() {
  var builder = oldBuilder.call(this);
  builder.root = builder;
  builder.repo = this.repo;
  return builder;
};