logger

(function() {
  var CryptographicBuffer, LOGGERS, WinJSFileAppender, WinJSRollingFileAppender, consoleAppender, fileAppender, getLogger, logLayout, rootLogger, stringEncoding,
    __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; };

  CryptographicBuffer = Windows.Security.Cryptography.CryptographicBuffer;

  stringEncoding = Windows.Security.Cryptography.BinaryStringEncoding.utf8;

  WinJSFileAppender = (function(_super) {

    __extends(WinJSFileAppender, _super);

    function WinJSFileAppender(filename, layout) {
      this.filename = filename != null ? filename : 'log.xml';
      if (layout == null) {
        layout = new log4javascript.XmlLayout();
      }
      this.setLayout(layout);
      this._queue = new Queue();
      return;
    }

    WinJSFileAppender.prototype.getOutputStreamAsync = function() {
      var _this = this;
      if (this._stream) {
        return WinJS.Promise.as(this._stream);
      } else {
        return this.getFileAsync().then(function(file) {
          return file.openAsync(Windows.Storage.FileAccessMode.readWrite);
        }).then(function(stream) {
          return _this._stream = stream.getOutputStreamAt(stream.size);
        });
      }
    };

    WinJSFileAppender.prototype.getFileAsync = function() {
      var _this = this;
      return Windows.Storage.ApplicationData.current.localFolder.createFolderAsync('logs', Windows.Storage.CreationCollisionOption.openIfExists).then(function(folder) {
        return folder.createFileAsync(_this.filename, Windows.Storage.CreationCollisionOption.openIfExists);
      });
    };

    WinJSFileAppender.prototype.append = function(loggingEvent) {
      this._queue.enqueue(loggingEvent);
      this._drainQueue();
    };

    WinJSFileAppender.prototype._drainQueue = function() {
      var drainScheduled,
        _this = this;
      if (this._queue.isEmpty()) {
        return;
      }
      if (this._draining) {
        drainScheduled = true;
        return;
      }
      this._draining = true;
      return this.getOutputStreamAsync().then(function(stream) {
        var buffer, logText, loggingEvent;
        logText = '';
        while (loggingEvent = _this._queue.dequeue()) {
          logText += _this.layout.format(loggingEvent);
          if (loggingEvent.exception && _this.layout.ignoresThrowable()) {
            logText += "" + (loggingEvent.getThrowableStrRep()) + "\r\n";
          }
        }
        buffer = CryptographicBuffer.convertStringToBinary(logText, stringEncoding);
        return stream.writeAsync(buffer);
      }).then(function() {
        _this._draining = false;
        if (drainScheduled) {
          return _this._drainQueue();
        }
      }, function() {
        return _this._draining = false;
      });
    };

    return WinJSFileAppender;

  })(log4javascript.Appender);

  WinJSRollingFileAppender = (function(_super) {

    __extends(WinJSRollingFileAppender, _super);

    function WinJSRollingFileAppender(layout) {
      WinJSRollingFileAppender.__super__.constructor.call(this, this._getFilename(), layout);
      this._registerListener();
    }

    WinJSRollingFileAppender.prototype.resetAsync = function() {
      var _this = this;
      return WinJS.Promise.as(this._drainQueue()).then(function() {
        var _ref;
        if (!_this._stream) {
          return;
        }
        if ((_ref = _this._timeOutPromise) != null) {
          _ref.cancel();
        }
        _this._stream.close();
        _this._stream = null;
        _this.filename = _this._getFilename();
        return _this._registerListener();
      });
    };

    WinJSRollingFileAppender.prototype._getFilename = function() {
      return "app" + (moment().format('YYYY-MM-DD')) + ".log";
    };

    WinJSRollingFileAppender.prototype._registerListener = function() {
      var _this = this;
      return setImmediate(function() {
        var waitFor;
        waitFor = moment().sod().add('d', 1).diff();
        return _this._timeOutPromise = WinJS.Promise.timeout(waitFor).then(function() {
          return _this.resetAsync();
        });
      });
    };

    return WinJSRollingFileAppender;

  })(WinJSFileAppender);

  rootLogger = log4javascript.getRootLogger();

  logLayout = new log4javascript.PatternLayout('%d - [%c - %p] - %m%n');

  log4javascript.setShowStackTraces(true);

  if (config.debug) {
    rootLogger.setLevel(log4javascript.Level.TRACE);
    rootLogger.addAppender(consoleAppender = new log4javascript.BrowserConsoleAppender());
    consoleAppender.layout = logLayout;
    consoleAppender.setThreshold(log4javascript.Level.TRACE);
  }

  fileAppender = new WinJSRollingFileAppender(logLayout);

  rootLogger.addAppender(fileAppender);

  WinJS.Application.addEventListener('checkpoint', function(event) {
    return event.setPromise(fileAppender.resetAsync());
  });

  Windows.UI.WebUI.WebUIApplication.addEventListener("resuming", function(event) {
    fileAppender.resetAsync();
  });

  LOGGERS = {};

  getLogger = function(name, defaultLevel) {
    var level, logLevelSetting, logger;
    if (defaultLevel == null) {
      defaultLevel = "DEBUG";
    }
    if (LOGGERS[name]) {
      return LOGGERS[name];
    }
    logger = log4javascript.getLogger(name);
    logLevelSetting = "loglevel-" + name;
    level = settings.get(logLevelSetting, defaultLevel);
    logger.setLevel(log4javascript.Level[level]);
    Object.defineProperty(logger, "level", {
      enumerable: true,
      get: function() {
        return logger.getLevel().name || defaultLevel;
      },
      set: function(newValue) {
        settings.set(logLevelSetting, newValue);
        return logger.setLevel(log4javascript.Level[newValue]);
      }
    });
    LOGGERS[name] = logger;
    return logger;
  };

  window.logger = rootLogger;

  WinJS.Namespace.define('logger', {
    get: getLogger,
    all: {
      get: function() {
        var logger, name, _results;
        _results = [];
        for (name in LOGGERS) {
          if (!__hasProp.call(LOGGERS, name)) continue;
          logger = LOGGERS[name];
          _results.push({
            name: name,
            logger: logger
          });
        }
        return _results;
      }
    }
  });

}).call(this);