'use strict';

var debug = require('debug')('wt');
var path = require('path');
var fs = require('fs');
var Base = require('sdk-base');
var util = require('util');
var ndir = require('ndir');

module.exports = Watcher;
module.exports.Watcher = Watcher;

/**
 * Watcher
 *
 * @param {Object} options
 *  - {Boolean} [ignoreNodeModules] ignore node_modules or not, default is `true`
 *  - {Boolean} [ignoreHidden] ignore hidden file or not, default is `true`
 *  - {Number} [rewatchInterval] auto rewatch root dir interval,
 *  	default is `0`, don't rewatch.
 * @param {Function} [done], watch all dirs done callback.
 */
function Watcher(options) {
  Base.call(this);
  // http://nodejs.org/dist/v0.11.12/docs/api/fs.html#fs_caveats
  // The recursive option is currently supported on OS X.
  // Only FSEvents supports this type of file watching
  // so it is unlikely any additional platforms will be added soon.

  options = options || {};
  if (options.ignoreHidden === undefined || options.ignoreHidden === null) {
    options.ignoreHidden = true;
  }
  if (options.ignoreNodeModules === undefined || options.ignoreNodeModules === null){
    options.ignoreNodeModules = true;
  }
  this._ignoreHidden = !!options.ignoreHidden;
  this._ignoreNodeModules = !!options.ignoreNodeModules;
  this._rewatchInterval = options.rewatchInterval;

  this.watchOptions = {
    persistent: true,
    recursive: false, // so we dont use this features
  };

  this._watchers = {};
  this._rootDirs = [];
  this._rewatchTimer = null;
  if (this._rewatchInterval && typeof this._rewatchInterval === 'number') {
    this._rewatchTimer = setInterval(this._rewatchRootDirs.bind(this), this._rewatchInterval);
    debug('start rewatch timer every %dms', this._rewatchInterval);
  }
}

Watcher.watch = function (dirs, options, done) {
  // watch(dirs, done);
  if (typeof options === 'function') {
    done = options;
    options = null;
  }

  var watcher = new Watcher(options).watch(dirs);
  if (typeof done === 'function') {
    var count = Array.isArray(dirs) ? dirs.length : 1;
    watcher.on('watch', function () {
      count--;
      if (count === 0) {
        done();
      }
    });
  }
  return watcher;
};

util.inherits(Watcher, Base);

var proto = Watcher.prototype;

proto.isWatching = function (dir) {
  return !!this._watchers[dir];
};

/**
 * Start watch dir(s)
 *
 * @param  {Array|String} dirs: dir path or path list
 * @return {this}
 */
proto.watch = function (dirs) {
  if (!Array.isArray(dirs)) {
    dirs = [dirs];
  }
  debug('watch(%j)', dirs);
  for (var i = 0; i < dirs.length; i++) {
    var dir = dirs[i];
    this._watchDir(dir);
    if (this._rootDirs.indexOf(dir) === -1) {
      this._rootDirs.push(dir);
    }
  }
  return this;
};

proto.unwatch = function (dirs) {
  if (!Array.isArray(dirs)) {
    dirs = [dirs];
  }

  for (var i = 0; i < dirs.length; i++) {
    var dir = dirs[i];
    this._unwatchDir(dir);
    if (this._rootDirs.indexOf(dir) !== -1) {
      // remove from root dirs
      this._rootDirs.splice(this._rootDirs.indexOf(dir), 1);
    }
  }
  return this;
};

proto.close = function () {
  for (var k in this._watchers) {
    this._watchers[k].close();
    this._watchers[k].removeAllListeners();
    this._watchers[k] = null;
  }
  this._watchers = {};

  // 等待一个事件循环后再移除所有时间，确保 watcher 的 error 事件还能被捕获
  setImmediate(function () {
    this.removeAllListeners();
  }.bind(this));
  if (this._rewatchTimer) {
    clearInterval(this._rewatchTimer);
    this._rewatchTimer = null;
  }
};

proto._rewatchRootDirs = function () {
  for (var i = 0; i < this._rootDirs.length; i++) {
    var dir = this._rootDirs[i];
    // watcher missing, meaning dir was deleted
    // try to rewatch again
    this._watchDirIfExists(dir);
  }
};

proto._watchDirIfExists = function (dir) {
  var that = this;
  fs.stat(dir, function (err, stat) {
    debug('[watchDirIfExists] %s, error: %s, exists: %s', dir, err, !!stat);
    if (stat && stat.isDirectory()) {
      if (!that._watchers[dir]) {
        // watch again!
        that._watchDir(dir);
      }
    } else if (!stat) {
      // not exists, close watcher
      that._unwatchDir(dir);
    }
  });
};

proto._watchDir = function (dir) {
  var watchers = this._watchers;
  var that = this;
  debug('walking %s...', dir);
  ndir.walk(dir).on('dir', function (dirpath) {
    if (path.basename(dirpath)[0] === '.' && that._ignoreHidden) {
      debug('ignore hidden dir: %s', dirpath);
      return;
    }
    if (path.basename(dirpath) === 'node_modules' && that._ignoreNodeModules){
      debug('ignore node_modules dir: %s', dirpath);
      return;
    }
    if (watchers[dirpath]) {
      debug('%s exists', dirpath);
      return;
    }
    debug('fs.watch(%s) start...', dirpath);
    var watcher;
    try {
      watcher = fs.watch(dirpath, that.watchOptions, that._handle.bind(that, dirpath));
    } catch (err) {
      err.dir = dirpath;
      that.emit('error', err);
      return;
    }
    watchers[dirpath] = watcher;
    watcher.once('error', that._onWatcherError.bind(that, dirpath));
  }).on('error', function (err) {
    err.dir = dir;
    that.emit('error', err);
  }).on('end', function () {
    debug('_watchDir(%s) done', dir);
    // debug('now watching %s', Object.keys(that._watchers));
    that.emit('watch', dir);
  });
  return this;
};

proto._unwatchDir = function (dir) {
  var watcher = this._watchers[dir];
  debug('unwatch %s, watcher exists: %s', dir, !!watcher);
  if (watcher) {
    watcher.close();
    watcher.removeAllListeners();
    delete this._watchers[dir];
    this.emit('unwatch', dir);
  }
  // should close all subdir watchers too
  var subdirs = Object.keys(this._watchers);
  for (var i = 0; i < subdirs.length; i++) {
    var subdir = subdirs[i];
    if (subdir.indexOf(dir + '/') === 0) {
      // close subdir watcher
      watcher = this._watchers[subdir];
      watcher.close();
      watcher.removeAllListeners();
      delete this._watchers[subdir];
      debug('close subdir %s watcher by %s', subdir, dir);
    }
  }
};

proto._onWatcherError = function (dir, err) {
  this._unwatchDir(dir);
  err.dir = dir;
  this.emit('error', err);
};

proto._handle = function (root, event, name) {
  var that = this;
  if (!name) {
    debug('[WARNING] event:%j, name:%j not exists on %s', root);
    return;
  }
  if (name[0] === '.' && this._ignoreHidden) {
    debug('ignore %s on %s/%s', event, root, name);
    return;
  }
  if (name === 'node_modules' && this._ignoreNodeModules) {
    debug('ignore %s on %s/%s', event, root, name);
    return;
  }
  // check root stat
  fs.exists(root, function (exists) {
    if (!exists) {
      debug('[handle] %s %s on %s, root not exists', event, name, root);
      that._handleChange({
        event: event,
        path: path.join(root, name),
        stat: null,
        remove: true,
        isDirectory: false,
        isFile: false,
      });

      // linux event, dir self remove, will fire `rename with dir name itself`
      if (that._watchers[root]) {
        debug('[handle] fire root:%s %s by %s', root, event, name);
        that._handleChange({
          event: event,
          path: root,
          stat: null,
          remove: true,
          isDirectory: true,
          isFile: false,
        });
      }
      return;
    }

    // children change
    debug('[handle] %s %s on %s, root exists', event, name, root);
    var fullpath = path.join(root, name);
    fs.stat(fullpath, function (err, stat) {
      var info = {
        event: event,
        path: fullpath,
        stat: stat,
        remove: false,
        isDirectory: stat && stat.isDirectory() || false,
        isFile: stat && stat.isFile() || false,
      };
      if (err) {
        if (err.code === 'ENOENT') {
          info.remove = true;
        }
      }

      if (event === 'change' && info.remove) {
        // this should be a fs.watch bug
        debug('[WARNING] %s on %s, but file not exists, ignore this', event, fullpath);
        return;
      }
      that._handleChange(info);
    });
  });
};

proto._handleChange = function (info) {
  debug('_handleChange(%j)', info);
  var that = this;
  if (info.remove) {
    var watcher = that._watchers[info.path];
    if (watcher) {
      // close the exists watcher
      info.isDirectory = true;
      that._unwatchDir(info.path);
    }
  } else if (info.isDirectory) {
    var watcher = that._watchers[info.path];
    if (!watcher) {
      // add new watcher
      that._watchDir(info.path);
    }
  }
  that.emit('all', info);
  if (info.remove) {
    debug('[remove event] %s, isDirectory: %s', info.path, info.isDirectory);
    that.emit('remove', info);
  } else if (info.isFile) {
    debug('[file change event] %s', info.path);
    that.emit('file', info);
  } else if (info.isDirectory) {
    debug('[dir change envet] %s', info.path);
    that.emit('dir', info);
  }
};