// Change this function when the value of the predefined property RewriteJavaScript is 'full' 
function modifyScript(script)
{
  return script;
}

function runEventScript(mode, thisModule, triggeredObject, script)
{
  var originalModule = _currentModule;
  _currentModule = thisModule;
  triggeredObject._do = new Function("", mode == "partial" ? script : modifyScript(script));
  var rv = triggeredObject._do();
  _currentModule = originalModule;
  return rv;
}

function preRunScript(mode, thisModule, script)
{
  var returnedObject = new Object();
  returnedObject.savedContext = new Object;
  returnedObject.savedContext.originalModule = _currentModule;
  _currentModule = thisModule;
  returnedObject.script = (mode == "partial" ? script : modifyScript(script));
  return returnedObject;
}

function postRunScript(savedContext)
{
  _currentModule = savedContext.originalModule;
}

function preRunScriptSrc(mode, thisModule, script, cacheable, cacheKey, eTag, lastModified, expires)
{
  var returnedObject = new Object();
  returnedObject.savedContext = new Object;
  returnedObject.savedContext.originalModule = _currentModule;
  _currentModule = thisModule;
  returnedObject.script = (mode == "partial" ? script : modifyScript(script));
  return returnedObject;
}

function postRunScriptSrc(savedContext)
{
  _currentModule = savedContext.originalModule;
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlIsAbsoluteUrl(checkedUrl)
{
  var cHttp = "http://";
  var cHttps = "https://";

  return checkedUrl.substring(0, cHttp.length).toLowerCase() == cHttp ||
         checkedUrl.substring(0, cHttps.length).toLowerCase() == cHttps;
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlUrlWithoutQueryAndFragment(fullUrl)
{
  var lastPathCharacterIndex = fullUrl.length;
  var queryIndex = fullUrl.indexOf('?');
  var fragmentIndex1 = fullUrl.indexOf('#');
  
  if (queryIndex != -1)
    lastPathCharacterIndex = queryIndex;
  if (fragmentIndex1 != -1 && fragmentIndex1 < lastPathCharacterIndex)
    lastPathCharacterIndex = fragmentIndex1;
  
  return fullUrl.substring(0, lastPathCharacterIndex);
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlGetAbsolutizationBase ()
{
  var baseUrl = _currentModule.ProviderBaseUrl;
  baseUrl = wsmlUrlWithoutQueryAndFragment(baseUrl);

  if (baseUrl.charAt(baseUrl.length - 1) != '/')
  {
    var lastSlashPosition       = baseUrl.lastIndexOf('/');
    var schemeSeparatorPosition = baseUrl.indexOf('://');

    if (lastSlashPosition == schemeSeparatorPosition + 2) // No path at all - Add ending slash
      baseUrl = baseUrl + '/';
   	else
      baseUrl = baseUrl.substring(0, baseUrl.lastIndexOf('/') + 1); // Remove last path segment
  }

  return baseUrl;
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
// ************* This func is only used once!! **************
function wsmlFindBeginningOfPath(absoluteUrl)
{
  var schemeSeparatorPosition = absoluteUrl.indexOf('//');
  if (schemeSeparatorPosition == -1 || schemeSeparatorPosition+2 > absoluteUrl.length)
    return -1;
  var authoritySeparatorPosition = absoluteUrl.indexOf('/', schemeSeparatorPosition+2);

  return authoritySeparatorPosition;
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlMakeAbsoluteUrl(relativeUrl)
{
  var baseUrl = wsmlGetAbsolutizationBase();
  var baseBeginningOfPath = wsmlFindBeginningOfPath(baseUrl);

  var relativeUrlWithoutQueryAndFragment = wsmlUrlWithoutQueryAndFragment(relativeUrl);
  var firstPathDelimiterIndex = relativeUrlWithoutQueryAndFragment.indexOf('/');

  // remove leading ./ and ../
  var dotIndex    = -1;
  var dotDotIndex = -1;
  do
  {
    dotIndex    = relativeUrl.indexOf('./');
    dotDotIndex = relativeUrl.indexOf('../');

    // remove leading ./ from relative URL
    if (dotIndex == 0)
      relativeUrl = relativeUrl.substring(2,relativeUrl.length);       

    // remove leading ../ from relative URL and trim base path
    if (dotDotIndex == 0)
    {
     relativeUrl = relativeUrl.substring(3,relativeUrl.length);
     var lastBaseDelimiterIndex = baseUrl.lastIndexOf('/');
     var tmpBaseUrl = baseUrl.substring(0, lastBaseDelimiterIndex);
     lastBaseDelimiterIndex = tmpBaseUrl.lastIndexOf('/');
     tmpBaseUrl = tmpBaseUrl.substring(0, lastBaseDelimiterIndex+1);
     if (tmpBaseUrl.length >= baseBeginningOfPath)
       baseUrl = tmpBaseUrl;
     else
       dotDotIndex = -1; // terminate
    }
  }
  while (dotIndex == 0 || dotDotIndex == 0)
  
  if (firstPathDelimiterIndex == 0)
  {
    var baseUrlSchemeEndIndex = baseUrl.indexOf("//");
    var absoluteUrl = baseUrl.substring(0, baseUrl.indexOf('/', baseUrlSchemeEndIndex + 2));
    absoluteUrl += '/' + relativeUrl.substring(firstPathDelimiterIndex + 1);
    return absoluteUrl;
  }
  else
    return baseUrl + relativeUrl;
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlWsmlDataEscapeUrl(absoluteUrl)
{
  // Skip the scheme
  var schemeTokenEndIndex = absoluteUrl.indexOf('/') + 1;
  var wsmlDataEscapedUrl  = absoluteUrl.substring(0, schemeTokenEndIndex);

  // Replace instance chars
  
  var restOfUrl = absoluteUrl.substring(schemeTokenEndIndex);
  var chArr        = [  '%',   '!',   ',',   '~']; // % is the 1st one, to prevent double escaping
  var escapedChArr = ['%25', '%21', '%2c', '%7e'];
  
  for (var chIdx in chArr)
  {
    var tmpUrl = "";
    var instanceTokens = restOfUrl.split(chArr[chIdx]);
    var tokensLength = instanceTokens.length;
    if (tokensLength <= 1)
      tmpUrl = restOfUrl;
    else
    {
      tmpUrl = instanceTokens[0];
      for (var instanceIdx = 1; instanceIdx < tokensLength; instanceIdx++)
        tmpUrl += escapedChArr[chIdx] + instanceTokens[instanceIdx];
    }
    restOfUrl = tmpUrl;
  }

  wsmlDataEscapedUrl += restOfUrl;

  return wsmlDataEscapedUrl;
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlMakeResourceUrl(originalUrl)
{
  if (wsmlIsAbsoluteUrl(originalUrl))
    return originalUrl;
  else
  {    
    var cHttp = "http://";
    var absoluteOriginalUrl = wsmlMakeAbsoluteUrl(originalUrl);
    var originalUrlIsHttp  = (absoluteOriginalUrl.substring(0, cHttp.length).toLowerCase() == cHttp);
      
    if ((_currentModule.ProxyResourcesProperty == "always") ||
        ((_currentModule.ProxyResourcesProperty == "ssl-mismatch") &&
         (_currentModule.IsHttpsRequest) && (originalUrlIsHttp)))
    {
      var modifiedResourceUrl;
      
      if ((_currentModule.ProxyResourcesProperty == "always") &&          
          (((originalUrlIsHttp && !_currentModule.IsHttpsRequest) && 
            (_currentModule.SyndicatorSchemeProperty == "sync")) ||
           (_currentModule.SyndicatorSchemeProperty == "always-http")))          
      {
      	modifiedResourceUrl = 'http://' + _currentModule.SyndicatorDomain;
      }
      else
      {
        modifiedResourceUrl = 'https://' +_currentModule.SyndicatorSecureDomain;
      }      
      
      modifiedResourceUrl += _currentModule.ResourceUrlPrefix;
      modifiedResourceUrl += escape(wsmlWsmlDataEscapeUrl(absoluteOriginalUrl));
      modifiedResourceUrl += _currentModule.ResourceUrlSuffix;
      
      return modifiedResourceUrl;      
    }
    else
      return absoluteOriginalUrl;
  }
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlMakeLeakHref(originalUrl, originalTarget)
{
  if (_currentModule.HasLeak == true )
  {
    return wsmlMakeWebServiceHref(originalUrl, true, originalTarget);
  }

  if (wsmlIsAbsoluteUrl(originalUrl))
    return originalUrl;
  else
    return wsmlMakeAbsoluteUrl(originalUrl);
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlLocalFragmentedLinkAbsolutizer(newFragment)
{
  var hostUrl = new String(document.location);
  var originalFragment = new String(document.location.hash);
  
  var urlLength = hostUrl.length;
  var fragmentLength = originalFragment.length;
  
  var hostUrlWithoutFragment = hostUrl.substr(0, urlLength - fragmentLength);
  return(hostUrlWithoutFragment + newFragment);
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlMakeHrefSchemeAuthority(absoluteOriginalUrl)
{  
  var absoluteOriginalUrlUntilPath = wsmlUrlWithoutQueryAndFragment(absoluteOriginalUrl);
  var absoluteOriginalUrlUntilPathTokens = absoluteOriginalUrlUntilPath.split('/');
  var originalScheme =    absoluteOriginalUrlUntilPathTokens[0];
  var originalDomainAndOptionalPort = absoluteOriginalUrlUntilPathTokens[2];

  var syndicatorScheme;
  var syndicatorDomain;
  if ((_currentModule.SyndicatorSchemeProperty == 'always-http') || 
      ((_currentModule.SyndicatorSchemeProperty == 'sync') && (originalScheme.toLowerCase() == 'http:')))
  {
    syndciatorScheme = 'http:';
    syndicatorDomain = _currentModule.SyndicatorDomain;
  }
  else if ((_currentModule.SyndicatorSchemeProperty == 'always-https') || 
           ((_currentModule.SyndicatorSchemeProperty == 'sync') && (originalScheme.toLowerCase() == 'https:')))
  {
    syndciatorScheme = 'https:';
    syndicatorDomain = _currentModule.SyndicatorSecureDomain;
  }
  else
    return null;
    
  if (syndicatorDomain == null)
    return null;
    
  var schemeAuthority;
  schemeAuthority  = syndciatorScheme + '//';
  schemeAuthority += syndicatorDomain;
      
  return schemeAuthority;
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlMakeWebServiceHref(originalUrl, isLeak, leakTarget)
{
  var fragmentIndex2 = originalUrl.indexOf('#');
  var fragment     = '';

  if (fragmentIndex2 != -1)
  {
    if (fragmentIndex2 == 0)
      return wsmlLocalFragmentedLinkAbsolutizer(originalUrl);
        
    fragment    = originalUrl.substring(fragmentIndex2, originalUrl.length);
    originalUrl = originalUrl.substring(0,fragmentIndex2);
  }

  var absoluteLinkHrefOriginalUrl;
  if (wsmlIsAbsoluteUrl(originalUrl))
    absoluteLinkHrefOriginalUrl = originalUrl;
  else
    absoluteLinkHrefOriginalUrl = wsmlMakeAbsoluteUrl(originalUrl);

  var modifiedLinkHrefUrl;
  modifiedLinkHrefUrl  = wsmlMakeHrefSchemeAuthority(absoluteLinkHrefOriginalUrl);
  if (modifiedLinkHrefUrl == null)
    return absoluteLinkHrefOriginalUrl;
  modifiedLinkHrefUrl += _currentModule.HrefPrefix;
  modifiedLinkHrefUrl += escape(wsmlWsmlDataEscapeUrl(absoluteLinkHrefOriginalUrl));
  modifiedLinkHrefUrl += _currentModule.HrefCurrentUrlToBrokerInfo;
  modifiedLinkHrefUrl += ',';
  modifiedLinkHrefUrl += _currentModule.HrefContainerUrl;
  if (isLeak != null || leakTarget != null || _currentModule.LeakOnAllLinks == true)
  {
      modifiedLinkHrefUrl += ',';
      if (isLeak == true || _currentModule.LeakOnAllLinks == true)
          modifiedLinkHrefUrl += 'true';
      else
          modifiedLinkHrefUrl += 'false';
      if (leakTarget != null)
      {
          modifiedLinkHrefUrl += ',true,';
          modifiedLinkHrefUrl += leakTarget;
      }
  }
  modifiedLinkHrefUrl += _currentModule.HrefSuffix;
  modifiedLinkHrefUrl += fragment;
  
  return modifiedLinkHrefUrl;
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlMakeStandaloneUrl(originalUrl)
{
  var fragmentIndex2 = originalUrl.indexOf('#');
  var fragment     = '';

  if (fragmentIndex2 != -1)
  {
    if (fragmentIndex2 == 0)
      return wsmlLocalFragmentedLinkAbsolutizer(originalUrl);
        
    fragment    = originalUrl.substring(fragmentIndex2, originalUrl.length);
    originalUrl = originalUrl.substring(0,fragmentIndex2);
  }

  var absoluteLinkHrefOriginalUrl;
  if (wsmlIsAbsoluteUrl(originalUrl))
    absoluteLinkHrefOriginalUrl = originalUrl;
  else
    absoluteLinkHrefOriginalUrl = wsmlMakeAbsoluteUrl(originalUrl);

  var modifiedLinkHrefUrl;
  modifiedLinkHrefUrl  = wsmlMakeHrefSchemeAuthority(absoluteLinkHrefOriginalUrl);
  if (modifiedLinkHrefUrl == null)
    return absoluteLinkHrefOriginalUrl;
  modifiedLinkHrefUrl += _currentModule.StandaloneUrlPrefix;
  modifiedLinkHrefUrl += escape(wsmlWsmlDataEscapeUrl(absoluteLinkHrefOriginalUrl));
  modifiedLinkHrefUrl += _currentModule.StandaloneUrlCurrentUrlToBrokerInfo;
  modifiedLinkHrefUrl += ',';
  modifiedLinkHrefUrl += _currentModule.StandaloneUrlContainerUrl;
  if (_currentModule.LeakOnAllLinks == true)
  {
      modifiedLinkHrefUrl += ',';
      if (_currentModule.LeakOnAllLinks == true)
          modifiedLinkHrefUrl += 'true';
      else
          modifiedLinkHrefUrl += 'false';
  }
  modifiedLinkHrefUrl += _currentModule.StandaloneUrlSuffix;
  modifiedLinkHrefUrl += fragment;
  
  return modifiedLinkHrefUrl;
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlMakeEmbeddedUrl(originalUrl)
{
  var fragmentBegin  = originalUrl.indexOf('#');
  var fragmentString = '';

  if (fragmentBegin != -1)
  {
    if (fragmentBegin == 0)
      return wsmlLocalFragmentedLinkAbsolutizer(originalUrl);
        
    fragmentString = originalUrl.substring(fragmentBegin, originalUrl.length);
    originalUrl    = originalUrl.substring(0, fragmentBegin);
  }

  var absoluteOriginalUrl;
  if (wsmlIsAbsoluteUrl(originalUrl))
    absoluteOriginalUrl = originalUrl;
  else
    absoluteOriginalUrl = wsmlMakeAbsoluteUrl(originalUrl);

  var modifiedUrl;
  modifiedUrl  = wsmlMakeHrefSchemeAuthority(absoluteOriginalUrl);
  
  if (modifiedUrl == null)
    return absoluteOriginalUrl;

  modifiedUrl += _currentModule.EmbeddedUrlPrefix;
  modifiedUrl += escape(wsmlWsmlDataEscapeUrl(absoluteOriginalUrl));
  modifiedUrl += _currentModule.EmbeddedUrlCurrentUrlToBrokerInfo;
  modifiedUrl += ',';
  modifiedUrl += _currentModule.EmbeddedUrlContainerUrl;

  if (_currentModule.LeakOnAllLinks == true)
  {
      modifiedUrl += ',';
      if (_currentModule.LeakOnAllLinks == true)
          modifiedUrl += 'true';
      else
          modifiedUrl += 'false';
  }

  modifiedUrl += _currentModule.EmbeddedUrlSuffix;
  modifiedUrl += fragmentString;
  
  return modifiedUrl;
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlMakeOriginalUrl(url)
{
  if (wsmlIsAbsoluteUrl(url))
    return url;
  else
    return wsmlMakeAbsoluteUrl(url);
}


//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlMakeCssHref(originalUrl)
{
  var absoluteCssHrefOriginalUrl;
  if (wsmlIsAbsoluteUrl(originalUrl))
    absoluteCssHrefOriginalUrl = originalUrl;
  else
    absoluteCssHrefOriginalUrl = wsmlMakeAbsoluteUrl(originalUrl);

  var modifiedCssHrefUrl;
  modifiedCssHrefUrl  = wsmlMakeHrefSchemeAuthority(absoluteCssHrefOriginalUrl);
  if (modifiedCssHrefUrl == null)
    return absoluteCssHrefOriginalUrl;
  modifiedCssHrefUrl += _currentModule.CssHrefPrefix;
  modifiedCssHrefUrl += escape(wsmlWsmlDataEscapeUrl(absoluteCssHrefOriginalUrl));
  modifiedCssHrefUrl += _currentModule.CssHrefSuffix;
  
  return modifiedCssHrefUrl;
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlMakeComponentHref(originalUrl, isLeak, leakTarget)
{
  return wsmlMakeWebServiceHref(originalUrl, isLeak, leakTarget);
}

// Create Empty OnLoad Function Array if does not exist .
if (!window.wsmlOnLoadArray)
  window.wsmlOnLoadArray = new Array();

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlAddToWsmlOnLoad(newOnLoad)
{
  // - if first time store hosts onload in position 0
  if (window.wsmlOnLoadArray.length == 0)
  {
    window.wcHostOnLoad = window.onload;
    window.wsmlOnLoadArray[0] = function() {if (window.wcHostOnLoad) window.wcHostOnLoad()};
  }
  try
  {
    window.wsmlOnLoadArray[window.wsmlOnLoadArray.length] = new Function(newOnLoad);
  } catch (e){}
  window.onload = wsmlOnLoad;
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function wsmlOnLoad()
{
  // - invoke all functions in array but invoke position 0 last
  // - b/c this is where we stored the hosts onload
    
  for (var i=1; i < window.wsmlOnLoadArray.length; i++)
  {
    try 
	{
      if (window.wsmlOnLoadArray[i] != null)
	  {
	    window.wcSomeOnload = window.wsmlOnLoadArray[i];
	    window.wcSomeOnload();
	    window.wcSomeOnload = null;
	  }
	} catch (e){}
  }

  if (window.wsmlOnLoadArray[0] != null) 
	window.wsmlOnLoadArray[0]();
}

//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
function _wsmlWrite(text)
{
  document.write(text);
}