(function() {
  var EventEmitter, Parser, ProcStat, split,
    __hasProp = {}.hasOwnProperty,
    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

  EventEmitter = require('events').EventEmitter;

  split = require('split');

  Parser = require('../parser');

  ProcStat = (function(_super) {
    var RE_COLSEP, RE_CPULINE;

    __extends(ProcStat, _super);

    RE_CPULINE = /^cpu[0-9]+ .*$/mg;

    RE_COLSEP = /\ +/g;

    function ProcStat(sync) {
      this.sync = sync;
      this.interval = 1000;
      this.stats = this._emptyStats();
      this._ignore = {};
      this._timer = setInterval((function(_this) {
        return function() {
          return _this.update();
        };
      })(this), this.interval);
      this.update();
    }

    ProcStat.prototype.end = function() {
      clearInterval(this._timer);
      this.sync.end();
      return this.sync = null;
    };

    ProcStat.prototype.update = function() {
      return new Parser(this.sync.pull('/proc/stat')).readAll().then((function(_this) {
        return function(out) {
          return _this._parse(out);
        };
      })(this))["catch"]((function(_this) {
        return function(err) {
          _this._error(err);
        };
      })(this));
    };

    ProcStat.prototype._parse = function(out) {
      var cols, line, match, stats, total, type, val, _i, _len;
      stats = this._emptyStats();
      while (match = RE_CPULINE.exec(out)) {
        line = match[0];
        cols = line.split(RE_COLSEP);
        type = cols.shift();
        if (this._ignore[type] === line) {
          continue;
        }
        total = 0;
        for (_i = 0, _len = cols.length; _i < _len; _i++) {
          val = cols[_i];
          total += +val;
        }
        stats.cpus[type] = {
          line: line,
          user: +cols[0] || 0,
          nice: +cols[1] || 0,
          system: +cols[2] || 0,
          idle: +cols[3] || 0,
          iowait: +cols[4] || 0,
          irq: +cols[5] || 0,
          softirq: +cols[6] || 0,
          steal: +cols[7] || 0,
          guest: +cols[8] || 0,
          guestnice: +cols[9] || 0,
          total: total
        };
      }
      return this._set(stats);
    };

    ProcStat.prototype._set = function(stats) {
      var cur, found, id, loads, m, old, ticks, _ref;
      loads = {};
      found = false;
      _ref = stats.cpus;
      for (id in _ref) {
        cur = _ref[id];
        old = this.stats.cpus[id];
        if (!old) {
          continue;
        }
        ticks = cur.total - old.total;
        if (ticks > 0) {
          found = true;
          m = 100 / ticks;
          loads[id] = {
            user: Math.floor(m * (cur.user - old.user)),
            nice: Math.floor(m * (cur.nice - old.nice)),
            system: Math.floor(m * (cur.system - old.system)),
            idle: Math.floor(m * (cur.idle - old.idle)),
            iowait: Math.floor(m * (cur.iowait - old.iowait)),
            irq: Math.floor(m * (cur.irq - old.irq)),
            softirq: Math.floor(m * (cur.softirq - old.softirq)),
            steal: Math.floor(m * (cur.steal - old.steal)),
            guest: Math.floor(m * (cur.guest - old.guest)),
            guestnice: Math.floor(m * (cur.guestnice - old.guestnice)),
            total: 100
          };
        } else {
          this._ignore[id] = cur.line;
          delete stats.cpus[id];
        }
      }
      if (found) {
        this.emit('load', loads);
      }
      return this.stats = stats;
    };

    ProcStat.prototype._error = function(err) {
      return this.emit('error', err);
    };

    ProcStat.prototype._emptyStats = function() {
      return {
        cpus: {}
      };
    };

    return ProcStat;

  })(EventEmitter);

  module.exports = ProcStat;

}).call(this);