// Copyright 2006 Google Inc. All Rights Reserved.
// This startup script should be included in host pages either just after
// <body> or inside the <head> after module <meta> tags.
//

//////////////////////////////////////////////////////////////////////////////
// DynamicResources
//

function DynamicResources() {
  this.pendingElemsBySrc_ = {};
  this.pendingScriptElems_ = new Array();
}
DynamicResources.prototype = {};

// The array is set up such that, pairwise, the entries are (src, readyFnStr).
// Called once for each module that is attached to the host page.
// It is theoretically possible that addScripts() could be called reentrantly
// if the browser event loop is pumped during this function and an iframe loads; 
// we may want to enhance this method in the future to support that case.
DynamicResources.prototype.addScripts = function(scriptArray, insertBeforeElem) {
  var wasEmpty = (this.pendingScriptElems_.length == 0);
  var anyAdded = false;
  for (var i = 0, n = scriptArray.length; i < n; i += 2) {
    var src = scriptArray[i];
    if (this.pendingElemsBySrc_[src]) {
      // Don't load the same script twice.
      continue;
    }
    // Set up the element but don't add it to the DOM until its turn.
    anyAdded = true;
    var e = document.createElement("script");
    this.pendingElemsBySrc_[src] = e;
    var readyFn;
    eval("readyFn = " + scriptArray[i+1]);
    e.__readyFn = readyFn;
    e.type = "text/javascript";
    e.src = src;
    e.__insertBeforeElem = insertBeforeElem;
    this.pendingScriptElems_ = this.pendingScriptElems_.concat(e);
  }
  
  if (wasEmpty && anyAdded) {
    // Kickstart.
    this.injectScript(this.pendingScriptElems_[0]);
  }
}

DynamicResources.prototype.injectScript = function(scriptElem) {
  var parentElem = scriptElem.__insertBeforeElem.parentNode;
  parentElem.insertBefore(scriptElem, scriptElem.__insertBeforeElem);
}

DynamicResources.prototype.addStyles = function(styleSrcArray, insertBeforeElem) {
  var parent = insertBeforeElem.parentNode;
  for (var i = 0, n = styleSrcArray.length; i < n; ++i) {
    var src = styleSrcArray[i];
    if (this.pendingElemsBySrc_[src]) 
      continue;
    var e = document.createElement("link");
    this.pendingElemsBySrc_[src] = e;
    e.type = "text/css";
    e.rel = "stylesheet";
    e.href = src;
    parent.insertBefore(e, insertBeforeElem);
  }
}

DynamicResources.prototype.isReady = function() {
  var elems = this.pendingScriptElems_;
  if (elems.length > 0) {
    var e = elems[0];
    if (!e.__readyFn()) {
      // The pending script isn't ready yet.
      return false;
    }
    
    // The pending script has now finished loading. Enqueue the next, if any.
    e.__readyFn = null;
    elems.shift();
    if (elems.length > 0) {
      // There is another script.
      this.injectScript(elems[0]);
      return false;
    }
  }

  // There are no more pending scripts.
  return true;
}

//////////////////////////////////////////////////////////////////////////////
// ModuleControlBlock
//
function ModuleControlBlock(metaElem, rawName) {
  var parts = ["", rawName];
  var i = rawName.lastIndexOf("=");
  if (i != -1) {
    parts[0] = rawName.substring(0, i) + '/';
    parts[1] = rawName.substring(i+1);
  }

  this.metaElem_ = metaElem;
  this.baseUrl_ = parts[0];
  this.name_ = parts[1];
  this.compilationLoaded_ = false;
  this.frameWnd_ = null;
}
ModuleControlBlock.prototype = {};

/**
 * Determines whether this module is fully loaded and ready to run.
 */
ModuleControlBlock.prototype.isReady = function() {
  return this.compilationLoaded_;
};

/**
 * Called when the compilation for this module is loaded.
 */
ModuleControlBlock.prototype.compilationLoaded = function(frameWnd) {
  this.frameWnd_ = frameWnd;
  this.compilationLoaded_ = true;
}

/**
 * Gets the logical module name, not including a base url prefix if one was
 * specified.
 */
ModuleControlBlock.prototype.getName = function() {
  return this.name_;
}

/**
 * Gets the base URL of the module, guaranteed to end with a slash.
 */
ModuleControlBlock.prototype.getBaseURL = function() {
  return this.baseUrl_;
}

/**
 * Gets the window of the module's frame.
 */
ModuleControlBlock.prototype.getModuleFrameWindow = function() {
  return this.frameWnd_;
}

/**
 * Injects a set of dynamic scripts.
 * The array is set up such that, pairwise, the entries are (src, readyFnStr).
 */
ModuleControlBlock.prototype.addScripts = function(scriptSrcArray) {
  return ModuleControlBlocks.dynamicResources_.addScripts(scriptSrcArray, this.metaElem_);
}

/**
 * Injects a set of dynamic styles.
 */
ModuleControlBlock.prototype.addStyles = function(styleSrcArray) {
  return ModuleControlBlocks.dynamicResources_.addStyles(styleSrcArray, this.metaElem_);
}
 
//////////////////////////////////////////////////////////////////////////////
// ModuleControlBlocks
//
function ModuleControlBlocks() {
  this.blocks_ = [];
}
ModuleControlBlocks.dynamicResources_ = new DynamicResources(); // "static"
ModuleControlBlocks.prototype = {};

/**
 * Adds a module control control block for the named module.
 * @param metaElem the meta element that caused the module to be added
 * @param name the name of the module being added, optionally preceded by
 * an alternate base url of the form "_path_=_module_".
 */
ModuleControlBlocks.prototype.add = function(metaElem, name) {
  var mcb = new ModuleControlBlock(metaElem, name);
  this.blocks_ = this.blocks_.concat(mcb);
};

/**
 * Determines whether all the modules are loaded and ready to run.
 */
ModuleControlBlocks.prototype.isReady = function() {
  for (var i = 0, n = this.blocks_.length; i < n; ++i) {
    var mcb = this.blocks_[i];
    if (!mcb.isReady()) {
      return false;
    }
  }
  
  // Are there any pending dynamic resources (e.g. styles, scripts)?
  if (!ModuleControlBlocks.dynamicResources_.isReady()) {
    // No, we're still waiting on one or more dynamic resources.
    return false;
  }

  return true;
}

/**
 * Determines whether there are any module control blocks.
 */
ModuleControlBlocks.prototype.isEmpty = function() {
  return this.blocks_.length == 0;
}

/**
 * Gets the module control block at the specified index.
 */
ModuleControlBlocks.prototype.get = function(index) {
  return this.blocks_[index];
}

/**
 * Injects an iframe for each module.
 */
ModuleControlBlocks.prototype.injectFrames = function() {
  for (var i = 0, n = this.blocks_.length; i < n; ++i) {
    var mcb = this.blocks_[i];

    // Insert an iframe for the module
    var iframe = document.createElement("iframe");
    var selectorUrl = mcb.getBaseURL() + mcb.getName() + ".nocache.html";
    selectorUrl += "?" + (__gwt_isHosted() ? "h&" : "" ) + i;
    var unique = new Date().getTime();
    selectorUrl += "&" + unique;
    iframe.style.border = '0px';
    iframe.style.width = '0px';
    iframe.style.height = '0px';
    
    // Fragile browser-specific ordering issues below
    
/*@cc_on
    // prevent extra clicky noises on IE
    iframe.src = selectorUrl;
@*/
    
    if (document.body.firstChild) {
      document.body.insertBefore(iframe, document.body.firstChild);
    } else {
      document.body.appendChild(iframe);
    }
    
/*@cc_on
    // prevent extra clicky noises on IE
    return;
@*/

    if (iframe.contentWindow) {
      // Older Mozilla has a caching bug for the iframe and won't reload the nocache.
      iframe.contentWindow.location.replace(selectorUrl);
    } else {
      // Older Safari doesn't have a contentWindow.
      iframe.src = selectorUrl;
    }
  }
}

/**
 * Runs the entry point for each module.
 */
ModuleControlBlocks.prototype.run = function() {
  for (var i = 0, n = this.blocks_.length; i < n; ++i) {
    var mcb = this.blocks_[i];
    var name = mcb.getName();
    var frameWnd = mcb.getModuleFrameWindow();
    if (__gwt_isHosted()) {
      if (!window.external.gwtOnLoad(frameWnd, name)) {
        // Module failed to load.
        if (__gwt_onLoadError) {
            __gwt_onLoadError(name);
        } else {
            window.alert("Failed to load module '" + name + 
            "'.\nPlease see the log in the development shell for details.");
        }
      }
    } else {
      // The compilation itself handles calling the error function.
      frameWnd.gwtOnLoad(__gwt_onLoadError, name);
    }
  }
}

//////////////////////////////////////////////////////////////////////////////
// Globals
//

var __gwt_retryWaitMillis = 10;
var __gwt_isHostPageLoaded = false;
var __gwt_metaProps = {};
var __gwt_onPropertyError = null;
var __gwt_onLoadError = null;
var __gwt_moduleControlBlocks = new ModuleControlBlocks();

//////////////////////////////////////////////////////////////////////////////
// Common 
//

/**
 * Determines whether or not the page is being loaded in the GWT hosted browser.
 */
function __gwt_isHosted() {
  if (window.external && window.external.gwtOnLoad) {
    // gwt.hybrid makes the hosted browser pretend not to be
    if (document.location.href.indexOf("gwt.hybrid") == -1) {
      return true;
    }
  }
  return false;
}

/**
 * Tries to get a module control block based on a query string passed in from
 * the caller. Used by iframes to get references back to their mcbs.
 * @param queryString the entire query string as returned by location.search,
 * which notably includes the leading '?' if one is specified
 * @return the relevant module control block, or <code>null</code> if it cannot 
 * be derived based on <code>queryString</code>
 */
function __gwt_tryGetModuleControlBlock(queryString) {
  if (queryString.length > 0) {
    // The pattern is ?[h&]<index>[&<unique>]
    var queryString = queryString.substring(1);
    if (queryString.indexOf("h&") == 0) {
      // Ignore the hosted mode flag here; only GWTShellServlet cares about it.
      queryString = queryString.substring(2);
    }
    var pos = queryString.indexOf("&");
    if (pos >= 0) {
      queryString = queryString.substring(0, pos);
    }
    var mcbIndex = parseInt(queryString);
    if (!isNaN(mcbIndex)) {
      var mcb = __gwt_moduleControlBlocks.get(mcbIndex);
      return mcb;
    }
    // Ignore the unique number that remains on the query string.
  }
  return null;
}

/**
 * Parses meta tags from the host html.
 * 
 * <meta name="gwt:module" content="_module-name_">
 *    causes the specified module to be loaded
 *
 * <meta name="gwt:property" content="_name_=_value_">
 *    statically defines a deferred binding client property
 *
 * <meta name="gwt:onPropertyErrorFn" content="_fnName_">
 *    specifies the name of a function to call if a client property is set to 
 *    an invalid value (meaning that no matching compilation will be found)
 * 
 * <meta name="gwt:onLoadErrorFn" content="_fnName_">
 *    specifies the name of a function to call if an exception happens during 
 *    bootstrapping or if a module throws an exception out of onModuleLoad(); 
 *    the function should take a message parameter
 */
function __gwt_processMetas() {
  var metas = document.getElementsByTagName("meta");
  for (var i = 0, n = metas.length; i < n; ++i) {
    var meta = metas[i];
    var name = meta.getAttribute("name");
    if (name) {
      if (name == "gwt:module") {
        var moduleName = meta.getAttribute("content");
        if (moduleName) {
          __gwt_moduleControlBlocks.add(meta, moduleName);
        }
      } else if (name == "gwt:property") {
        var content = meta.getAttribute("content");
        if (content) {
          var name = content, value = "";
          var eq = content.indexOf("=");
          if (eq != -1) {
            name = content.substring(0, eq);
            value = content.substring(eq+1);
          }
          __gwt_metaProps[name] = value;
        }
      } else if (name == "gwt:onPropertyErrorFn") {
        var content = meta.getAttribute("content");
        if (content) {
          try {
            __gwt_onPropertyError = eval(content);
          } catch (e) {
            window.alert("Bad handler \"" + content + 
              "\" for \"gwt:onPropertyErrorFn\"");
          }
        }
      } else if (name == "gwt:onLoadErrorFn") {
        var content = meta.getAttribute("content");
        if (content) {
          try {
            __gwt_onLoadError = eval(content);
          } catch (e) {
            window.alert("Bad handler \"" + content + 
              "\" for \"gwt:onLoadErrorFn\"");
          }
        }
      }
    }
  }
}

/**
 * Determines the value of a deferred binding client property specified 
 * statically in host html.
 */
function __gwt_getMetaProperty(name) {
  var value = __gwt_metaProps[name];
  if (value) {
    return value;
  } else {
    return null;
  }
}

/**
 * Determines whether or not a particular property value is allowed.
 * @param wnd the caller's window object (not $wnd!)
 * @param propName the name of the property being checked
 * @param propValue the property value being tested
 */
function __gwt_isKnownPropertyValue(wnd, propName, propValue) {
  return propValue in wnd["values$" + propName];
}

/**
 * Called by the selection script when a property has a bad value or is missing.
 * 'allowedValues' is an array of strings. Can be hooked in the host page using 
 * gwt:onPropertyErrorFn.
 */
function __gwt_onBadProperty(moduleName, propName, allowedValues, badValue) {
  if (__gwt_onPropertyError) {
    __gwt_onPropertyError(moduleName, propName, allowedValues, badValue);
    return;
  } else {
    var msg = "While attempting to load module \"" + moduleName + "\", ";
    if (badValue != null) {
       msg += "property \"" + propName + "\" was set to the unexpected value \"" 
        + badValue + "\"";
    } else {
       msg += "property \"" + propName + "\" was not specified";
    }
    
    msg += "\n\nAllowed values: " + allowedValues;
   
    window.alert(msg);
  }
}

/**
 * Called directly from compiled code.
 */
function __gwt_initHandlers(resize, beforeunload, unload) {
   var oldOnResize = window.onresize;
   window.onresize = function() {
      resize();
      if (oldOnResize)
         oldOnResize();
   };

   var oldOnBeforeUnload = window.onbeforeunload;
   window.onbeforeunload = function() {
      var ret = beforeunload();

      var oldRet;
      if (oldOnBeforeUnload)
        oldRet = oldOnBeforeUnload();

      if (ret !== null)
        return ret;
      return oldRet;
   };

   var oldOnUnload = window.onunload;
   window.onunload = function() {
      unload();
      if (oldOnUnload)
         oldOnUnload();
   };
}

//////////////////////////////////////////////////////////////////////////////
// Hosted Mode
//
function __gwt_onUnloadHostedMode() {
    window.external.gwtOnLoad(null, null);
    if (__gwt_onUnloadHostedMode.oldUnloadHandler) {
        __gwt_onUnloadHostedMode.oldUnloadHandler();
    }
}

//////////////////////////////////////////////////////////////////////////////
// Bootstrap
//

/**
 * Waits until all startup preconditions are satisfied, then launches the 
 * user-defined startup code for each module.
 */
function __gwt_latchAndLaunch() {
  var ready = true;
  
  // Are there any compilations still pending?
  if (ready && !__gwt_moduleControlBlocks.isReady()) {
    // Yes, we're still waiting on one or more compilations.
    ready = false;
  }

  // Has the host html onload event fired?
  if (ready && !__gwt_isHostPageLoaded) {
    // No, the host html page hasn't fully loaded.
    ready = false;
  }
  
  // Are we ready to run user code?
  if (ready) {
    // Yes: run entry points.
    __gwt_moduleControlBlocks.run();
  } else {
    // No: try again soon.
    window.setTimeout(__gwt_latchAndLaunch, __gwt_retryWaitMillis);
  }
}

/**
 * Starts the module-loading sequence after meta tags have been processed and
 * the body element exists.
 */
function __gwt_loadModules() {
  // Make sure the body element exists before starting.
  if (!document.body) {
    // Try again soon.
    window.setTimeout(__gwt_loadModules, __gwt_retryWaitMillis);
    return;
  }

  // Inject a frame for each module.
  __gwt_moduleControlBlocks.injectFrames();

  // Try to launch module entry points once everything is ready.
  __gwt_latchAndLaunch();
}

/**
 * The very first thing to run, and it runs exactly once unconditionally.
 */
function __gwt_bootstrap() {
  // Hook onunload for hosted mode.
  if (__gwt_isHosted()) {
    __gwt_onUnloadHostedMode.oldUnloadHandler = window.onunload;
    window.onunload = __gwt_onUnloadHostedMode;
  }

  // Hook the current window onload handler.
  var oldHandler = window.onload;
  window.onload = function() {
    __gwt_isHostPageLoaded = true;
    if (oldHandler) {
      oldHandler();
    }
  };

  // Parse meta tags from host html.
  __gwt_processMetas();

  // Load any modules.
  __gwt_loadModules();
}

// Go.
__gwt_bootstrap();