goog.provide('webfont.FontWatchRunner');

goog.require('webfont.Font'); goog.require('webfont.FontRuler');

/**

* @constructor
* @param {function(webfont.Font)} activeCallback
* @param {function(webfont.Font)} inactiveCallback
* @param {webfont.DomHelper} domHelper
* @param {webfont.Font} font
* @param {number=} opt_timeout
* @param {Object.<string, boolean>=} opt_metricCompatibleFonts
* @param {string=} opt_fontTestString
*/

webfont.FontWatchRunner = function(activeCallback, inactiveCallback, domHelper,

  font, opt_timeout, opt_metricCompatibleFonts, opt_fontTestString) {
this.activeCallback_ = activeCallback;
this.inactiveCallback_ = inactiveCallback;
this.domHelper_ = domHelper;
this.font_ = font;
this.fontTestString_ = opt_fontTestString || webfont.FontWatchRunner.DEFAULT_TEST_STRING;
this.lastResortWidths_ = {};
this.timeout_ = opt_timeout || 3000;

this.metricCompatibleFonts_ = opt_metricCompatibleFonts || null;

this.fontRulerA_ = null;
this.fontRulerB_ = null;
this.lastResortRulerA_ = null;
this.lastResortRulerB_ = null;

this.setupRulers_();

};

/**

* @enum {string}
* @const
*/

webfont.FontWatchRunner.LastResortFonts = {

SERIF: 'serif',
SANS_SERIF: 'sans-serif'

};

/**

* Default test string. Characters are chosen so that their widths vary a lot
* between the fonts in the default stacks. We want each fallback stack
* to always start out at a different width than the other.
* @type {string}
* @const
*/

webfont.FontWatchRunner.DEFAULT_TEST_STRING = 'BESbswy';

goog.scope(function () {

var FontWatchRunner = webfont.FontWatchRunner,
    Font = webfont.Font,
    FontRuler = webfont.FontRuler;

/**
 * @type {null|boolean}
 */
FontWatchRunner.HAS_WEBKIT_FALLBACK_BUG = null;

/**
 * @return {string}
 */
FontWatchRunner.getUserAgent = function () {
  return window.navigator.userAgent;
};

/**
 * Returns true if this browser is WebKit and it has the fallback bug
 * which is present in WebKit 536.11 and earlier.
 *
 * @return {boolean}
 */
FontWatchRunner.hasWebKitFallbackBug = function () {
  if (FontWatchRunner.HAS_WEBKIT_FALLBACK_BUG === null) {
    var match = /AppleWebKit\/([0-9]+)(?:\.([0-9]+))/.exec(FontWatchRunner.getUserAgent());

    FontWatchRunner.HAS_WEBKIT_FALLBACK_BUG = !!match &&
                                        (parseInt(match[1], 10) < 536 ||
                                         (parseInt(match[1], 10) === 536 &&
                                          parseInt(match[2], 10) <= 11));
  }
  return FontWatchRunner.HAS_WEBKIT_FALLBACK_BUG;
};

/**
 * @private
 */
FontWatchRunner.prototype.setupRulers_ = function() {
  this.fontRulerA_ = new FontRuler(this.domHelper_, this.fontTestString_);
  this.fontRulerB_ = new FontRuler(this.domHelper_, this.fontTestString_);
  this.lastResortRulerA_ = new FontRuler(this.domHelper_, this.fontTestString_);
  this.lastResortRulerB_ = new FontRuler(this.domHelper_, this.fontTestString_);

  this.fontRulerA_.setFont(new Font(this.font_.getName() + ',' + FontWatchRunner.LastResortFonts.SERIF, this.font_.getVariation()));
  this.fontRulerB_.setFont(new Font(this.font_.getName() + ',' + FontWatchRunner.LastResortFonts.SANS_SERIF, this.font_.getVariation()));
  this.lastResortRulerA_.setFont(new Font(FontWatchRunner.LastResortFonts.SERIF, this.font_.getVariation()));
  this.lastResortRulerB_.setFont(new Font(FontWatchRunner.LastResortFonts.SANS_SERIF, this.font_.getVariation()));

  this.fontRulerA_.insert();
  this.fontRulerB_.insert();
  this.lastResortRulerA_.insert();
  this.lastResortRulerB_.insert();
};

FontWatchRunner.prototype.start = function() {
  this.lastResortWidths_[FontWatchRunner.LastResortFonts.SERIF] = this.lastResortRulerA_.getWidth();
  this.lastResortWidths_[FontWatchRunner.LastResortFonts.SANS_SERIF] = this.lastResortRulerB_.getWidth();

  this.started_ = goog.now();

  this.check_();
};

/**
 * Returns true if the given width matches the generic font family width.
 *
 * @private
 * @param {number} width
 * @param {string} lastResortFont
 * @return {boolean}
 */
FontWatchRunner.prototype.widthMatches_ = function(width, lastResortFont) {
  return width === this.lastResortWidths_[lastResortFont];
};

/**
 * Return true if the given widths match any of the generic font family
 * widths.
 *
 * @private
 * @param {number} a
 * @param {number} b
 * @return {boolean}
 */
FontWatchRunner.prototype.widthsMatchLastResortWidths_ = function(a, b) {
  for (var font in FontWatchRunner.LastResortFonts) {
    if (FontWatchRunner.LastResortFonts.hasOwnProperty(font)) {
      if (this.widthMatches_(a, FontWatchRunner.LastResortFonts[font]) &&
          this.widthMatches_(b, FontWatchRunner.LastResortFonts[font])) {
        return true;
      }
    }
  }
  return false;
};

/**
 * @private
 * Returns true if the loading has timed out.
 * @return {boolean}
 */
FontWatchRunner.prototype.hasTimedOut_ = function() {
  return goog.now() - this.started_ >= this.timeout_;
};

/**
 * Returns true if both fonts match the normal fallback fonts.
 *
 * @private
 * @param {number} a
 * @param {number} b
 * @return {boolean}
 */
FontWatchRunner.prototype.isFallbackFont_ = function (a, b) {
  return this.widthMatches_(a, FontWatchRunner.LastResortFonts.SERIF) &&
         this.widthMatches_(b, FontWatchRunner.LastResortFonts.SANS_SERIF);
};

/**
 * Returns true if the WebKit bug is present and both widths match a last resort font.
 *
 * @private
 * @param {number} a
 * @param {number} b
 * @return {boolean}
 */
FontWatchRunner.prototype.isLastResortFont_ = function (a, b) {
  return FontWatchRunner.hasWebKitFallbackBug() && this.widthsMatchLastResortWidths_(a, b);
};

/**
 * Returns true if the current font is metric compatible. Also returns true
 * if we do not have a list of metric compatible fonts.
 *
 * @private
 * @return {boolean}
 */
FontWatchRunner.prototype.isMetricCompatibleFont_ = function () {
  return this.metricCompatibleFonts_ === null || this.metricCompatibleFonts_.hasOwnProperty(this.font_.getName());
};

/**
 * Checks the width of the two spans against their original widths during each
 * async loop. If the width of one of the spans is different than the original
 * width, then we know that the font is rendering and finish with the active
 * callback. If we wait more than 5 seconds and nothing has changed, we finish
 * with the inactive callback.
 *
 * @private
 */
FontWatchRunner.prototype.check_ = function() {
  var widthA = this.fontRulerA_.getWidth();
  var widthB = this.fontRulerB_.getWidth();

  if (this.isFallbackFont_(widthA, widthB) || this.isLastResortFont_(widthA, widthB)) {
    if (this.hasTimedOut_()) {
      if (this.isLastResortFont_(widthA, widthB) && this.isMetricCompatibleFont_()) {
        this.finish_(this.activeCallback_);
      } else {
        this.finish_(this.inactiveCallback_);
      }
   } else {
      this.asyncCheck_();
    }
  } else {
    this.finish_(this.activeCallback_);
  }
};

/**
 * @private
 */
FontWatchRunner.prototype.asyncCheck_ = function() {
  setTimeout(goog.bind(function () {
    this.check_();
  }, this), 50);
};

/**
 * @private
 * @param {function(webfont.Font)} callback
 */
FontWatchRunner.prototype.finish_ = function(callback) {
  // Remove elements and trigger callback (which adds active/inactive class) asynchronously to avoid reflow chain if
  // several fonts are finished loading right after each other
  setTimeout(goog.bind(function () {
    this.fontRulerA_.remove();
    this.fontRulerB_.remove();
    this.lastResortRulerA_.remove();
    this.lastResortRulerB_.remove();
    callback(this.font_);
  }, this), 0);
};

});