function notImplemented( functionBody )
{
    var bodyString = new String( functionBody );
    alert( bodyString.substring( 0, bodyString.indexOf( ")" ) + 1 ) + " is not implemented!" );
}

// Function prototypes for thirdparty users
function initGameScript( tThirdPartySource, tLanguage, tCountry, tSource )  { notImplemented( arguments.callee ); }
function getDownloadUrl( gameID, gameType, overInstall )                    { notImplemented( arguments.callee ); }
function getBuyUrl( gameID, priceID, gameType )                             { notImplemented( arguments.callee ); }
function getBuyGpUrl( gpType, initTerm )                                    { notImplemented( arguments.callee ); }
function getActivateGpUrl( initTerm )                                       { notImplemented( arguments.callee ); }
function getUserReviewUrl( gameID, gameType, access )                       { notImplemented( arguments.callee ); }
function getScreenShotsUrl( gameID, gameType )                              { notImplemented( arguments.callee ); }
function getGameMessageBoardUrl( gameID, gameType, lang )                   { notImplemented( arguments.callee ); }
function getMessageBoardUrl( boardId )                                      { notImplemented( arguments.callee ); }
function getGameTellAFriendUrl( gameID, gameType )                          { notImplemented( arguments.callee ); }
function getTellAFriendUrl( tellAFriendId )                                 { notImplemented( arguments.callee ); }
function getLaunchWebGameUrl( gameID, webPlayUrl, urlArguments )            { notImplemented( arguments.callee ); }
function getGamePageUrl( gameID, gameType )                                 { notImplemented( arguments.callee ); }
function getGenrePageUrl( genreId )                                         { notImplemented( arguments.callee ); }
function getFaqPageUrl( faqId )                                             { notImplemented( arguments.callee ); }
function getPageUrl( pType )                                                { notImplemented( arguments.callee ); }
function getPromoPage( gameID, promoType )                                  { notImplemented( arguments.callee ); }
function getCouponPage( gameID, ecqs )                                              { notImplemented( arguments.callee ); }

// Internal functions and variables for Url generating functions.
function RealArcade()
{
    this.GENERATE_URL_ERROR = "error in generating url";
    this.DEFAULT_PRICE_ID = "4";
    this.DEFAULT_GAME_TYPE = "download";
    this.DEFAULT_GP_TYPE = "full";
    this.VALIDATION_ACTION_ERROR = "action=error";
    this.BASE_URL = "http://switchboard.real.com/arcade/feeds.html";
    this.TPS = "tps";
    this.LANG = "lang";
    this.COUNTRY = "country";
    this.PARTNER = "partner";
    this.GAMEID = "gameid"
    this.CLIENT = "client";
    this.GAMETYPE = "gametype";
    this.OVERINSTALL = "overinstall";
    this.DOWNLOADTYPE = "dltype";
    this.RACINSTALLED = "arcadeinstalled";
    this.GAMEPASSTYPE = "gptype";
    this.ACCESS = "access";
    this.BOARDID = "boardid";
    this.TAFID = "tafid";
    this.GENREID = "genreid";
    this.GENRETYPE = "genretype";
    this.PAGETYPE = "ptype";
    this.PROMOTYPE = "promotype";
    this.FAQTYPE = "faqtype";
    this.FAQID = "faqid";
    this.COUPON = "ecqs";
    this.SOURCECONTENT = "sourcecontent";
    this.INIT_TERM = "init_term";
    this.SRC = "src";
    this.ACTION = "action";
    this.PRICEID = "priceid";
    this.SHOCKWAVE = "shockwave";
    this.JAVA = "java";
    this.DOWNLOAD_ACTION		    = "download";
    this.BUYURL_ACTION			    = "buy";
    this.BUYGP_ACTION			    = "buy_gp";
    this.ACTIVATEGP_ACTION		    = "activate_gp";
    this.USERREVIEW_ACTION		    = "user_review";
    this.SCREENSHOTS_ACTION		    = "screen_shots";
    this.MESSAGEBOARD_ACTION	    = "message_board";
    this.TELLAFRIEND_ACTION		    = "tell_a_friend";
    this.LAUNCHWEBGAME_ACTION	    = "launch_web_game";
    this.PAGE_ACTION			    = "page";
    this.COMMON_ACTION			    = "common";
    this.DEFAULT_GAME_PAGE_TYPE     = "game";
    this.DEFAULT_GENRE_PAGE_TYPE    = "gpage";
    this.DEFAULT_FAQ_PAGE_TYPE      = "topfaqs";
    this.DEFAULT_PROMO_PAGE_TYPE    = "0";
    this.PROMO_PAGE_TYPE            = "promo";
    this.DOWNLOADTYPE_RDX           = "rdxbundle";
    this.DOWNLOADTYPE_BUNDLE        = "bundle";
    this.DOWNLOADTYPE_GAME          = "game";
    this.WEB_PLAY_URL               ="web_play_url";
    this.ACTION_RANGE = [ this.DOWNLOAD_ACTION,
                          this.BUYURL_ACTION,
                          this.BUYGP_ACTION,
                          this.ACTIVATEGP_ACTION,
					      this.USERREVIEW_ACTION,
					      this.SCREENSHOTS_ACTION,
					      this.MESSAGEBOARD_ACTION,
					      this.TELLAFRIEND_ACTION,
					      this.LAUNCHWEBGAME_ACTION,
					      this.PAGE_ACTION,
					      this.PROMO_ACTION,
					      this.COMMON_ACTION ];

    this.usePartnerPages = "1";
    this.baseUrl = "";
    this.thirdPartySource = "";
    this.language = "";
    this.country = "";
    this.client = "";
    this.source = "";
    this.racInstalled = "";
    this.racDistCode = "";
    this.shockwaveInstalled = "";
    this.javaEnabled = "";

    this.allValidMappings = [ {name:this.ACTION,
						  range:this.ACTION_RANGE,
						  validateFunction:validateEnumeration},

						 {name:this.TPS,
						  range:null,
						  validateFunction:validateNotNull},

						 {name:this.LANG,
						  range:null,
						  validateFunction:validateNotNull},

						 {name:this.COUNTRY,
						  range:null,
						  validateFunction:validateNotNull},

						 {name:this.GAMEID,
						  range:null,
						  validateFunction:validateGameID},

						 {name:this.CLIENT,
						  range:["web", "arcade", "player"],
						  validateFunction:validateEnumeration},

                         {name:this.GAMETYPE,
                          range:["download", "palm", "web"],
                          validateFunction:validateEnumeration},

                         {name:this.OVERINSTALL,
                          range:["yes", "no"],
                          validateFunction:validateEnumeration},

                         {name:this.DOWNLOADTYPE,
                          range:[this.DOWNLOADTYPE_RDX, this.DOWNLOADTYPE_BUNDLE, this.DOWNLOADTYPE_GAME],
                          validateFunction:validateEnumeration},

                         {name:this.RACINSTALLED,
                          range:[ 1, 0 ],
                          validateFunction:validateEnumeration},

                         {name:this.GAMEPASSTYPE,
                          range:["full", "trial"],
                          validateFunction:validateEnumeration},

                         {name:this.ACCESS,
                          range:["read", "write"],
                          validateFunction:validateEnumeration},

                         {name:this.BOARDID,
                          range:["index", "rac", "general", "tips", "news",
                                 "comments", "de_games", "de_rac"],
                          validateFunction:validateEnumeration},

                         {name:this.TAFID,
                          range:["rac", "gamepass"],
                          validateFunction:validateEnumeration},

                         {name:this.PAGETYPE,
                          range:["game", "gpage", "topfaqs", "index", "featured", "allgames", "helpdesk",
                                 "eula", "ppolicy", "feedback", "gamepass", "custserv", "myacct", "gupdates",
                                 "sysreqs", "ractour", "realarcade", "gptrial", "gpfull", "promo"],
                          validateFunction:validateEnumeration},

                         {name:this.FAQID,
                          range:null,
                          validateFunction:validateNotNull},

						  {name:this.INIT_TERM,
						   range:null,
						   validateFunction:validateNumber},

						  {name:this.SRC,
						   range:null,
						   validateFunction:validateNotNull},

  						  {name:this.PRICEID,
						   range:["4", "3", "2", "1", "0"],
						   validateFunction:validateEnumeration},

						  {name:this.WEB_PLAY_URL,
						   range:[1, 2, 3, 4, 5],
						   validateFunction:validateEnumeration}

					   ];

}

var realArcade = new RealArcade();


function validateGameID( gameID )
{
	return (gameID.length > 0) && (gameID.match("\\W") == null);
}

function validateNumber( num )
{
	if( typeof( num ) == "string" )
	{
		return (num.search( "^\\d+$" ) != -1);
	}
	return (typeof(num) == "number" );
}

function validateNotNull( val )
{
	return (val != null);
}

function validateEnumeration( item, list )
{
    for( var i = 0; i < list.length; i++ )
    {
        if( list[i] == item )
        {
			return true;
        }
    }
    return false;
}

function validateUrl( url )
{
	var regex = "(((https?)|(ftp)):\\/\\/([\\-\\w]+\\.)+\\w{2,3}(\\/[%\\-\\w]+(\\.\\w{2,})?)*(([\\w\\-\\.\\?\\\\/+@&amp;#;`~=%!]*)(\\.\\w{2,})?)*\\/?)";
	return ( url.search(regex) == 0 && url.search("\\s") == -1);
}

function validateArgument( argName, argValue )
{
	var validateMap = realArcade.allValidMappings[ argName ];
	if( validateMap != null)
	{
		var isRangeValidation = ( validateMap.range != null && validateMap.validateFunction != null );
		var isValueValidation = ( validateMap.validateFunction != null );

		if( isRangeValidation  )
		{
			return validateMap.validateFunction( argValue, validateMap.range );
		}
		else if( isValueValidation )
		{
			return validateMap.validateFunction( argValue );
		}
	}
	return true;
}

function createArcadeVersionControl()
{
    var control;

    try
    {
        control = new ActiveXObject('RNGCIECtl.RNGCIECtl.1');
    }
    catch ( e )
    {
    }

	return control;
}

function getRacDistCode()
{
	var undefined;
	if( isBrowerIE5OrAbove() )
	{
		var arcadeVersionControl = createArcadeVersionControl();
		if ( undefined == arcadeVersionControl )
		{
			return undefined;
		}
		return arcadeVersionControl.RealArcadeDistCode;
	} 
	else 
	{
		try
		{
			//create embed tag for plugin
			var embedNode = document.createElement('EMBED');
			document.body.appendChild(embedNode); 
			embedNode.setAttribute('width',0);
			embedNode.setAttribute('height',0);
			embedNode.setAttribute('type','application/vnd.rn-realarcade-javascript');
			//set reference to plugin
			var npracplug = document.embeds[0];
			// force the browser to 'parse' the plugin
			var str='';
			for (o in npracplug) {str = npracplug[o]};
			//get distcode
			if ( npracplug.RealArcadeDistCode().length > 0 ) 
			{
				return npracplug.RealArcadeDistCode();
			}
			else
			{
				return undefined;
			}
		}
		catch(e){return undefined;};
	}
}

function isRacInstalled()
{
	var undefined;
	var dc = getRacDistCode();

	if ( undefined == dc )
	{
	    if(navigator.appName == "Netscape")
        {
	        if ((navigator.userAgent.charAt(8)) >= ('3'))
	        {
	            var i=0;
	            while (navigator.plugins[i])
	            {
		            //document.write( navigator.plugins[i].name + '<br><br>');
	                if ((navigator.plugins[i].name) == 'RealArcade NS Plugin' || (navigator.plugins[i].name) == 'RealOne Arcade NS Plugin')
	                {
	                    return 1;
	                }
	                i++;
	            }
	        }
        }
        return 0;
	}
	else
	{
		return 1;
	}
}

function isShockwaveInstalled()
{
    if (window.ActiveXObject)
    {
        try
        {
            oShock= new ActiveXObject('SWCtl.SWCtl');

            if (oShock)
            {
                return 1;
            }
        }
        catch(e) {}
    }
    return 0;
}

function isJavaEnabled()
{
    if ( navigator.javaEnabled() )
    {
        return 1;
    }

    return 0;
}

function isPageLoadedByRealPlayer()
{
    var agent = navigator.userAgent.toLowerCase();

    return agent.match( "\\(r1" ) != null;
}

function isBrowerIE5OrAbove()
{
    var agent = navigator.userAgent.toLowerCase();
    var isIE = ((agent.indexOf("msie") != -1) && (agent.indexOf("opera") == -1));

    return (isIE && parseInt(navigator.appVersion) >= 4 && agent.indexOf("msie 4")== -1 );

}

function initGameScript( tThirdPartySource, tLanguage, tCountry, tSource )
{
    realArcade.baseUrl = realArcade.BASE_URL;
    realArcade.thirdPartySource = tThirdPartySource;
    realArcade.language = tLanguage;
    realArcade.country = tCountry;
    //detect realone player and change client to PLAYER if we have player installed/running??
    if ( isPageLoadedByRealPlayer() )
    {
        realArcade.client = "player";
    }
    else
    {
        realArcade.client = "web";
    }
    realArcade.source = tSource;
    realArcade.racInstalled = isRacInstalled();
    realArcade.racDistCode = getRacDistCode();
    realArcade.shockwaveInstalled = isShockwaveInstalled();
    realArcade.javaEnabled = isJavaEnabled();

    for (var i = 0; i < realArcade.allValidMappings.length; ++ i )
    {
		realArcade.allValidMappings[ realArcade.allValidMappings[i].name ] = realArcade.allValidMappings[i];
    }
}

function generateQueryString()
{
    var returnString = "";
    var undefined;

    if( arguments.length > 0 && (arguments.length % 2) == 0 )
    {
        if( ! validateArgument( arguments[0], arguments[1] ) )
        {
            debugOutput( "1) failed in validating " + arguments[0] + ", " + arguments[1] );
            return realArcade.VALIDATION_ACTION_ERROR;
        }
        returnString = arguments[0] + "=" + arguments[1];

        for( var i = 2; i < arguments.length; i +=2 )
        {
            var nameIndex = i;
            var valueIndex = i+1;

            if ( arguments[valueIndex] != undefined )
            {
                if(! validateArgument( arguments[nameIndex], arguments[valueIndex] ) )
                {
                    debugOutput( "2) failed in validating " + arguments[nameIndex] + ", " + arguments[valueIndex] );
      			    return realArcade.VALIDATION_ACTION_ERROR;
                }

                returnString += "&" + arguments[nameIndex] + "=" + arguments[valueIndex];
            }
        }
    }
    return returnString;
}

function getCommonUrl(action)
{
    var queryString = generateQueryString( realArcade.TPS,      realArcade.thirdPartySource,
                                           realArcade.LANG,     realArcade.language,
                                           realArcade.COUNTRY,  realArcade.country,
                                           realArcade.CLIENT,   realArcade.client,
                                           realArcade.PARTNER,  realArcade.usePartnerPages,
                                           realArcade.SRC,      realArcade.source,
                                           realArcade.ACTION,   action );
    return realArcade.baseUrl + "?" + queryString;

}

function getDownloadUrl( gameID, gameType, overInstall )
{
    var undefined;
    var dlType = realArcade.DOWNLOADTYPE_BUNDLE;

    if ( gameID == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    if ( gameType == undefined )
    {
        gameType = realArcade.DEFAULT_GAME_TYPE;
    }

    var queryString = generateQueryString(realArcade.GAMEID,        gameID,
                                          realArcade.GAMETYPE,      gameType,
                                          realArcade.OVERINSTALL,   overInstall,
                                          realArcade.DOWNLOADTYPE,  dlType,
                                          realArcade.RACINSTALLED,  realArcade.racInstalled );
    return getCommonUrl( realArcade.DOWNLOAD_ACTION ) + "&" + queryString;
}

function getBuyUrl( gameID, priceID, gameType )
{
    var undefined;

    if ( gameID == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    if ( priceID == undefined )
    {
        priceID = realArcade.DEFAULT_PRICE_ID;
    }

    if ( gameType == undefined )
    {
        gameType = realArcade.DEFAULT_GAME_TYPE;
    }

    var queryString = generateQueryString(realArcade.GAMEID,    gameID,
                                          realArcade.PRICEID,   priceID,
                                          realArcade.GAMETYPE,  gameType,
                                          realArcade.RACINSTALLED,  realArcade.racInstalled );
    return getCommonUrl( realArcade.BUYURL_ACTION ) + "&" + queryString;
}

function getBuyGpUrl( gpType, initTerm )
{
    var undefined;

    if ( gpType == undefined )
    {
        gpType = realArcade.DEFAULT_GP_TYPE;
    }

    if( initTerm == undefined )
    {
        initTerm = "1";
    }

    var queryString = generateQueryString(realArcade.GAMEPASSTYPE, gpType,
                                          realArcade.RACINSTALLED,  realArcade.racInstalled,
                                          realArcade.INIT_TERM, initTerm );

    return getCommonUrl( realArcade.BUYGP_ACTION ) + "&" + queryString;

}

function getActivateGpUrl( initTerm )
{
    var queryString = generateQueryString(realArcade.INIT_TERM, initTerm );
    return getCommonUrl( realArcade.ACTIVATEGP_ACTION ) + "&" + queryString;
}

function getUserReviewUrl( gameID, gameType, access )
{
    var undefined;

    if ( gameID == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    if ( access == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    if ( gameType == undefined )
    {
        gameType = realArcade.DEFAULT_GAME_TYPE;
    }

    var queryString = generateQueryString(realArcade.GAMEID, gameID,
                                          realArcade.GAMETYPE, gameType,
                                          realArcade.ACCESS, access);
    return getCommonUrl(realArcade.USERREVIEW_ACTION) + "&" + queryString;
}


function getScreenShotsUrl( gameID, gameType )
{
    var undefined;

    if ( gameID == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    if ( gameType == undefined )
    {
        gameType = realArcade.DEFAULT_GAME_TYPE;
    }
    var queryString = generateQueryString( realArcade.GAMEID,    gameID,
                                           realArcade.GAMETYPE,  gameType );
    return getCommonUrl( realArcade.SCREENSHOTS_ACTION ) + "&" + queryString;
}

function getGameMessageBoardUrl( gameID, gameType, langID )
{
    var undefined;

    if ( gameID == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    if ( gameType == undefined )
    {
        gameType = realArcade.DEFAULT_GAME_TYPE;
    }

    if( langID == undefined )
    {
        langID = realarcade.DEFAULT_LANG_ID;
    }


    var queryString = generateQueryString( realArcade.GAMEID,    gameID,
                                           realArcade.GAMETYPE,  gameType,
                                           realArcade.LANG, langID );

    return getCommonUrl(realArcade.MESSAGEBOARD_ACTION) + "&" + queryString;
}

function getMessageBoardUrl( boardId )
{
    var undefined;

    if ( boardId == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    var queryString = generateQueryString( realArcade.BOARDID, boardId );

    return getCommonUrl( realArcade.MESSAGEBOARD_ACTION ) + "&" + queryString;
}

function getGameTellAFriendUrl( gameID, gameType )
{
    var undefined;

    if ( gameID == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    if ( gameType == undefined )
    {
        gameType = realArcade.DEFAULT_GAME_TYPE;
    }

    var queryString = generateQueryString( realArcade.GAMEID, gameID,
                                           realArcade.GAMETYPE, gameType);

    return getCommonUrl( realArcade.TELLAFRIEND_ACTION ) + "&" + queryString;
}

function getTellAFriendUrl( tellAFriendId )
{
    var undefined;

    if ( tellAFriendId == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    var queryString = generateQueryString( realArcade.TAFID, tellAFriendId );

    return getCommonUrl( realArcade.TELLAFRIEND_ACTION ) + "&" + queryString;
}

function getLaunchWebGameUrl( gameID, webPlayUrl, urlArguments )
{
    var undefined;

    if ( gameID == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    if ( webPlayUrl == undefined )
    {
		return realArcade.GENERATE_URL_ERROR;
	}

    var queryString = generateQueryString( realArcade.GAMEID,       gameID,
                                           realArcade.SHOCKWAVE,    realArcade.shockwaveInstalled,
                                           realArcade.JAVA,         realArcade.javaEnabled,
                                           realArcade.WEB_PLAY_URL,	webPlayUrl );

	if ( urlArguments != undefined )
	{
		queryString = queryString + "&" + urlArguments;
	}

    return getCommonUrl( realArcade.LAUNCHWEBGAME_ACTION ) + "&" + queryString;
}


function getGamePageUrl( gameID, gameType )
{
    var undefined;

    var pType = realArcade.DEFAULT_GAME_PAGE_TYPE;

    if ( gameID == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    if ( gameType == undefined )
    {
        gameType = realArcade.DEFAULT_GAME_TYPE;
    }

    var queryString = generateQueryString( realArcade.PAGETYPE, pType,
										   realArcade.GAMEID,   gameID,
                                           realArcade.GAMETYPE, gameType );

    return getCommonUrl( realArcade.PAGE_ACTION ) + "&" + queryString;
}

function getGenrePageUrl( genreId )
{
    var undefined;

    var pType = realArcade.DEFAULT_GENRE_PAGE_TYPE;

    if ( genreId == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    var queryString = generateQueryString( realArcade.PAGETYPE, pType,
				                           realArcade.GENREID,  genreId );

    return getCommonUrl( realArcade.PAGE_ACTION ) + "&" + queryString;
}

function getFaqPageUrl( faqId )
{
    var undefined;

    var pType = realArcade.DEFAULT_FAQ_PAGE_TYPE;

    if ( faqId == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    var queryString = generateQueryString( realArcade.PAGETYPE, pType,
                                           realArcade.FAQID,    faqId);

    return getCommonUrl( realArcade.PAGE_ACTION ) + "&" + queryString;
}


function getPageUrl( pType )
{
    var undefined;

    if ( pType == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    var queryString = generateQueryString( realArcade.PAGETYPE, pType );

    return getCommonUrl( realArcade.PAGE_ACTION ) + "&" + queryString;
}

function getPromoPage( gameID, promoType )
{
    var undefined;

    var pType = realArcade.PROMO_PAGE_TYPE;

    if ( gameID == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    if( promoType == undefined )
    {
        promoType = realArcade.DEFAULT_PROMO_PAGE_TYPE;
    }

    var queryString = generateQueryString( realArcade.PAGETYPE, pType,
                                           realArcade.GAMEID, gameID,
                                           realArcade.PROMOTYPE, promoType );

    return getCommonUrl( realArcade.PAGE_ACTION ) + "&" + queryString;
}

function getCouponPage( gameID, ecqs )
{
    var undefined;

    //var pType = realArcade.PROMO_PAGE_TYPE;

    if ( ecqs == undefined || gameID == undefined )
    {
        return realArcade.GENERATE_URL_ERROR;
    }

    var queryString = generateQueryString(  realArcade.GAMEID, gameID,
                                            realArcade.COUPON, ecqs,
											realArcade.RACINSTALLED,  realArcade.racInstalled );

    return getCommonUrl( realArcade.BUYURL_ACTION ) + "&" + queryString;
}