/*
Dieses Skript ist Eigentum der xplosion interactive GmbH.
Version: v2.8
*/
var XPTraceLog = "";
var XPDoLogging = false;
var XPFBConsoleOut = false;
var XPProfActive = true;
var XPPGBActive = true;
var XPRand;
var XPPGBRes = false;
var XPSysError = false;
var XPIsSSL = false;
var XPConfigPreset = false;

var XPCondRes;
var XPCondAnyRes = false;
var XPXPPrtc;
var XPCConf;
var XPParams;
var XPPGBTrcData;
var XPCDNLoc = 'cdn.xplosion.de';
var XPCDNSSLLoc = 'ssl.xplosion.de';
var XPExtCConf;

function XPProfiling(params)
{
	try
	{
		//Generate Timestamp to avoid caching
		XPRand=Math.random()*10000000000000000000;
		XPLogTrace ('Timestamp generated: ' + XPRand);
		
		if (XPProfActive)
		{		
			XPParams = params;
			
			///Protocol detection
			XPPrtc = top.location.protocol;
			if (XPPrtc == "file:")
			{
				XPPrtc = "http:";
			}
			else if (XPPrtc == "http:")
			{
				XPIsSSL = false;
			}
			else if (XPPrtc == "https:")
			{
				XPIsSSL = true;
			}
	
			XPLogTrace ('Protocol detection: ' + XPPrtc + "//");
			
			if (!XPConfigPreset)
			{
				// Site/Network
				if (XPParams.site_id)
					XPParams.customer_id = XPParams.site_id;
					
					delete XPParams.site_id;
	
				if (!XPParams.customer_id)
				{
					XPDetectCus();
				}
				else
					XPLoadCusC(XPParams.customer_id);
			}
			else
			{
				XPLogTrace ('Customer config preset mode');
				
				if (XPExtCConf !== undefined && XPExtCConf != null)
				{
					XPExecP(XPExtCConf);
				}
				else
				{
					XPLogError ('F001: External customer config is null');	
				}					
			}		
			
		}
	}
	catch (error)
	{
		XPLogError ('F000: ' + error);
		XPLogTrace ('Tag call aborted.');
		
	}
}

function XPExecP(conf)
{
	
	
	XPCConf = conf;
	
	// Piggy-backing
	var pbn = 0;
	
	try
	{
		if (XPProfActive)
		{
			if(XPCConf)
			{
				if (XPCConf.config.pactive)
				{					
					XPLogTrace ('Customer determined and config loaded: ' + XPCConf.customerid + ' (' + XPCConf.networkid + ')');	

					//Read eventtype from parameters
					var ev=XPParam(XPParams.event_id);

					if (ev !== undefined && ev != null && ev != "")
					{

						XPLogTrace ('Event type determined: ' + ev);
						
						if (XPCConf.config.tagtype == 1 || XPCConf.config.tagtype == 2)
						{
						
							if (XPCConf.config.pgbmode == 1 || XPCConf.config.pgbmode == 2)
							{
							
								//Determine parammode
								if (XPCConf.config.autoparam !== undefined && XPCConf.config.autoparam)
								{
									XPLogTrace ('Autoparam mode enabled.');
									
									if (XPCConf.pvars === undefined)
									{
										XPLogWarn ('Autoparam mode enabled but no variables defined.');	
									}
						
									///Merge given params with autoparam list
									for (var param in XPCConf.pvars)
									{
										XPLogTrace ('Set or overwrite param "'+param+'" by auto param');
										XPParams[param] = XPCConf.pvars[param];
									}	
								}	
								
								///Read PGB trace Data
								XPLoadPGBTrcData();		
		
								//Read and execute piggyback condition
								if(XPPGBActive && XPCConf.config.pgbactive)
								{
									
									try
									{
										XPLogTrace ('PGBMode: ' + ((XPCConf.config.pgbmode == 1)? 'old mode':'new mode'));
										
										if (document.cookie.indexOf(XPCConf.config.pgbccname+'=true') == -1)
										{
											with (XPParams)
											{
												var counter = 0;
												XPCondRes = new Object();
												for (var cond in XPCConf.pgbcond)
												{
													XPCondRes[cond] = eval(XPCConf.pgbcond[cond]);
													XPLogTrace ('Piggyback condition '+cond+' executed: '+XPCConf.pgbcond[cond]+'. Condition Result: ' + XPCondRes[cond]);
												
													if (XPCondRes[cond])
													{
														XPCondAnyRes = true;
													}
													
													counter++;
												}
												
												if (counter > 1 && XPCConf.config.pgbmode == 1)
												{
													XPLogWarn ('Old piggyback mode enabled but multiple piggyback conditions defined.');
												}
																						
											}										
		
										}
										else
										{
											XPLogTrace ('Piggyback cache detected');
										}
									}
									catch (error)
									{
										XPLogError ('F002: Piggyback condition error: '+XPCConf.pgbcond+'. Error: ' + error);
									}
								}
								else
								{
									XPLogWarn ('Piggybacking disabled.');
								}
		
								//Determine if it is an order
								var isOrder = false;
								if (ev == "order")
								{
									isOrder = true;
									XPLogTrace ('Order detected');
								}
								
		
								
								//1 = old mode, 2 = new mode
								if (XPCondAnyRes && XPCConf.config.pgbmode == 1)
								{
									pbn = 1;
								}
		
								//Write profiling/checkout tag
								if (!isOrder)
								{				
									//1 = iframe, 2 = javascript
									if (XPCConf.config.tagtype == 1)
									{
										// Heias
										var s= XPPrtc + "//ads.heias.com/x/heias.ret.px.fr/?PX=HT|"+XPRand+"|n|"+XPCConf.networkid+"|cus|"+XPCConf.customerid+"|pb|"+pbn + XPCreateParamList(XPParams, XPCConf);
		
										XPLogTrace ('Profiling system request prepared (iframe, ppx): ' + s);
		
										// Heias Call
										document.write('<div id="px_div_'+XPRand+'" style="position: absolute; left:0; top:0; width:0px; height:0px;"><iframe id="px_fr_'+XPRand+'" name="px_fr_'+XPRand+'" src="'+s+'" allowtransparency="true" framespacing="0" frameborder="no" scrolling="no" width="1" height="1"  onerror="XPSysError = true; XPLogError (\'F011: Requesting profiling system failed. No piggybacks set.\');"  onload="XPLogTrace (\'Successful tag call (iframe)\');"></iframe></div>');
									}
									else if (XPCConf.config.tagtype == 2)
									{
										var heias_ref='-';
										try{ heias_ref=escape((document.location==top.document.location)?document.location:top.document.location);}catch(e){heias_ref='-'} if(parent==top) {heias_ref = escape(document.referrer);} window.heias_ref = heias_ref;
										var heias_fl_ver=0;try{heias_fl_ver=XPDetectFlash();}catch(e){heias_fl_ver=''}
		
										var s= XPPrtc + "//ads.heias.com/x/heias.ret.px/?PX=HT|" + XPRand + "|fl_ver|" + heias_fl_ver + "|js_var|"+screen.width+","+screen.height+","+navigator.cookieEnabled+"|n|"+XPCConf.networkid+"|cus|"+XPCConf.customerid+"|pb|"+pbn + XPCreateParamList(XPParams, XPCConf);
		
										XPLogTrace ('Profiling system request prepared (js, ppx): ' + s);
		
										document.write('<scr' + 'ipt language="JavaScript" type="text/javascript" src="' + s + '" onerror="XPSysError = true; XPLogError (\'F011: Requesting profiling system failed. No piggybacks set.\');" onload="XPLogTrace (\'Successful tag call (js)\');"><\/scr' + 'ipt>');
										
									}
								}
								else
								{
									// Heias Call
									var s =  XPPrtc + "//ads.heias.com/x/heias.cpa/count.px.js/?PX=HT|"+XPRand+"|cus|"+XPCConf.customerid+"|pb|"+pbn + XPCreateParamList(XPParams, XPCConf);
		
									XPLogTrace ('Profiling system request prepared: (js, chkout) ' + s);
		
									document.write('<scr' + 'ipt language="JavaScript" type="text/javascript" src="'+s+'"  onerror="XPSysError = true;  XPLogError (\'F011: Requesting profiling system failed. No piggybacks set.\');"  onload="XPDoPGB(); XPLogTrace (\'Successful checkout call (js)\');"><\/scr' + 'ipt>');
		
								}
								
								///Set PGB Trace data
								XPSetPGBTrcData();
								
								window.setTimeout('XPDoPGB();', 1000);
							}
							else
							{
								XPLogError ('F014: Invalid pgb mode. Call aborted.');
							}
						}
						else
						{
							XPLogError ('F013: Invalid tagtype. Call aborted.');	
						}

						
					}
					else
					{
						XPLogError ('F003: No event defined. Call aborted.');

					}
				}
				else
				{
					XPLogWarn ('Profiling is deactivated')
				}
			}
			else
			{
				XPLogError ('F004: Customer_id was not provided and unable to detect customer id by hostname. Call aborted.');
				
			}
		}
		else
		{
			XPLogWarn ('Profiling was disabled.');
		}
		
	}
	catch (error)
	{
		XPLogError ('F000: ' + error);
		XPLogTrace ('Tag call aborted.');
		
	}
}

function XPCheckEventVisits(event, cond)
{
	var result = false;
	
	if (XPCConf.config.pgbtracing)
	{
		if (event != null && event != '' && cond != null && cond != '')
		{
			var code = 'if (XPPGBTrcData.trc.c_' + XPCConf.customerid + ' !== undefined && XPPGBTrcData.trc.c_' + XPCConf.customerid + '.e_' + XPParams.event_id + ' !== undefined) { result = (XPPGBTrcData.trc.c_'+XPCConf.customerid+'.e_' + event + ' ' + cond + '); }';
			eval(code);
		}
	}
	else
	{
		XPLogWarn ('PGB tracing condition used but pgb tracing is disabled.');	
	}
	
	return result;	
}

function XPDoPGB ()
{
	///Write piggybacks (new mode)
	//1 = Old mode, 2 = new mode
	if (XPCondAnyRes && XPCConf.config.pgbmode == 2)
	{
		XPLogTrace ('Writing Piggybacks (new mode)...');
			
		var pgbsDone = new Object();	
		var pgbCouter = 0;
		for (var cond in XPCondRes)
		{
			XPLogTrace ('Processing condition result of ' + cond);
			if (XPCondRes[cond] == true)
			{
				XPLogTrace ('Following piggybacks matching this condition: ' + XPCConf.pgbconf[cond]);
				
				var arr = XPCConf.pgbconf[cond].split(',');
				for (i = 0; i < arr.length; i++)
				{
					var currPGBId = arr[i];
					
					if (pgbsDone[currPGBId] === undefined || pgbsDone[currPGBId] == false)
					{
						var pgbUrl = XPCConf.pgbs[currPGBId].replace(/\[timestamp\]/, XPRand).replace(/\[protocol\]/, XPPrtc);
						
						var currentPGBImg = document.createElement('img');
						currentPGBImg.width = 1;
						currentPGBImg.height = 1;
						currentPGBImg.border = 0;
						currentPGBImg.src = pgbUrl;
						
						pgbsDone[currPGBId] = true;
						
						XPLogTrace ('Firing piggyback '+currPGBId+': ' + pgbUrl);
						
						pgbCouter++;
					}
					else
					{
						XPLogTrace ('Piggyback '+currPGBId+' already fired. Ignored.');	
					}
				}
			}	
		}
		
		if (pgbCouter == 0)
			XPLogWarn('New piggyback mode enabled but no piggybacks defined.');
		
		if (XPCConf.config.pgbcaching)
			XPPBCCookie();
	}
}

function XPLoadPGBTrcData ()
{	
	try
	{
		if (XPCConf.config.pgbtracing)
		{
			XPLogTrace ('Loading PGBTrace data');
			
			var cValueArr = document.cookie.split(';');
			var found = false;
			var content = '';
			
			for (i = 0; i < cValueArr.length; i++)
			{	
				if (cValueArr[i].indexOf(XPCConf.config.pgbtrccname+'=') != -1)
				{
					content = unescape(cValueArr[i].split('=')[1]);
					found = true;	
					break;			
				}
			}
			
			if (!found)
				XPLogTrace ('No PGBTrace data found.');
			else
				XPLogTrace ('PGBTrace data found: ' + content);
			
			eval('XPPGBTrcData = { trc: {' + content + '} };');	
		}
		else
		{
			XPLogTrace ('PGB tracing disabled');
		}
				
	}
	catch (error)
	{
		XPLogError ('F000: ' + error);
	}
}

function XPSetPGBTrcData ()
{
	try
	{
		if (XPCConf.config.pgbtracing)
		{
			XPLogTrace ('Writing PGB trace data');
			
			if (XPPGBTrcData !== undefined && XPPGBTrcData !== null)
			{
				var cmd = 'if (XPPGBTrcData.trc.c_' + XPCConf.customerid + ' === undefined) { XPPGBTrcData.trc.c_' + XPCConf.customerid + ' = new Object(); }';
				eval (cmd);
				
				cmd = 'if (XPPGBTrcData.trc.c_' + XPCConf.customerid + '.e_' + XPParams.event_id + ' === undefined) { XPPGBTrcData.trc.c_' + XPCConf.customerid + '.e_' + XPParams.event_id + ' = 0; }';
				eval (cmd);
							
				cmd = 'XPPGBTrcData.trc.c_' + XPCConf.customerid + '.e_' + XPParams.event_id + '++;';
				eval (cmd);
					
				var serializedpgbtrc = '';
				for (var e1 in XPPGBTrcData.trc)
				{
					serializedpgbtrc = serializedpgbtrc + e1 + ': {';			
					for (var e2 in XPPGBTrcData.trc[e1])
					{
						serializedpgbtrc = serializedpgbtrc + e2 + ': ' + XPPGBTrcData.trc[e1][e2] + ',';	
					}
					serializedpgbtrc = serializedpgbtrc.substr(0,(serializedpgbtrc.length-1));
					serializedpgbtrc = serializedpgbtrc + '},';
				}
				serializedpgbtrc = serializedpgbtrc.substr(0,(serializedpgbtrc.length-1));
				
				var lifetime = 0;
				lifetime = (XPCConf.config.pgbtrclifetime !== undefined)? XPCConf.config.pgbtrclifetime:0;
				var expiryDateStr = '';
				if (lifetime > 0)
				{
					var expiryDate = new Date();
					expiryDate.setTime(expiryDate.getTime() + (lifetime * 60 * 60 * 1000));
					expiryDateStr = expiryDate.toLocaleString();
				}
				
				document.cookie =  XPCConf.config.pgbtrccname+'='+escape(serializedpgbtrc)+'; expires='+expiryDateStr+'; path=/;';	
				XPLogTrace ('Trace cookie set, expires in '+lifetime+' hours at ' + expiryDateStr);
		
			}
			else
			{
				XPLogError ('F012: XPPGBTrcData null or undefined');
			}			
		}
		

	}
	catch (error)
	{
		XPLogError ('F000: ' + error);
	}
}

function XPCreateParamList(p, config)
{
	try
	{
		
		
		
		var varList = "";
		for (var param in XPParams)
		{	
			if (param != "customer_id")
			{
				XPLogTrace ('Param processing: ' + param + '=' +  XPParams[param]);
				
				///Rename/Map param names
				var paramName = (eval('config.pmap.'+param) === undefined)? param:eval('config.pmap.'+param);
			
				if (paramName !== undefined && paramName != null)
				{
					if (XPParams[param] == null || (XPParams[param]+'') == "")
					{		
						XPLogError ('F005: Error while creating paramlist. Empty, null or invalid value for '+paramName+' paramter found.');						
					}
					else
					{
						var paramVal = escape(unescape(p[param]));
						if (paramVal != p[param])
							XPLogTrace ('Parameter value was escaped: ' + paramVal);
						
						varList += "|" + paramName + "|" + paramVal;
						XPLogTrace ('Param mapping ('+((param==paramName)? "no":"yes")+'): ' + param + ' -> ' + paramName);
					}
				}
				else
				{					
					XPLogError ('F006: Error while creating paramlist. Invalid paramname found, is null or undefined.');
				}
				
			
			}
					
		} 
	}
	catch (error)
	{
		XPLogError ('F000: ' + error);
		XPLogTrace ('Tag call aborted.');
	}
	
	return varList;
}

function XPCheckout(p)
{
   XPParams.event_id = "order";
   XPProfiling (XPParams);
}

function XPLoadCusC(s)
{	
	try
	{	
		///Protocol detection
		var XPPrtc = top.location.protocol;
		if (XPPrtc == "file:")
		{
			XPPrtc = "http:";
		}
	
		var CDNLocation = (XPIsSSL)? XPCDNSSLLoc:XPCDNLoc;
	
		var cconfUrl = XPPrtc + '//'+CDNLocation+'/'+s+'.js';
		XPLogTrace ('Loading customer config: ' + cconfUrl);
	
		document.write('<scr'+'ipt src="'+cconfUrl+'" id="XPCConfig_'+XPRand+'" type="text/JavaScript" onerror="XPLogError(\'F010: Loading customer config failed\');"><\/scr'+'ipt>');
	
	}
	catch (error)
	{	
		XPLogError ('F000: ' + error);
	}
}

function XPDetectCus ()
{
	try
	{
		var domain = top.location.host;
		var domainArray = domain.split('.');

		var numDomainParts = domainArray.length;
		var newDomain = domainArray[numDomainParts-2] + "." + domainArray[numDomainParts-1];
		
		XPLogTrace ('Customer auto-detection by hostname: ' + domain);		

		return XPLoadCusC(newDomain);
	}
	catch (error)
	{	
		XPLogError ('F000: ' + error);	
	}
}


function XPParam(a){
   if(a){
     return a;
   }
   return "";
}

function XPLogEntry (message, entryType)
{
	try
	{
		if (XPDoLogging !== undefined)
		{
			if (XPDoLogging)
			{
				var currEntry;
				if (message && message != '')
				{
					currEntry = entryType + ' ['+new Date()+']'+ ((XPRand === undefined)? '':('\t'+XPRand)) +'\t'+message + '\n';
					XPTraceLog += currEntry;
					
					if (XPFBConsoleOut && console !== undefined)
					{	
						if (entryType == 'INFO')
							console.log(currEntry);
						else if (entryType == 'ERR')
							console.error(currEntry);
						else if (entryType == 'WARN')
							console.warn(currEntry);
					}
				}
			}
		}
	}
	catch (error)
	{
		XPTraceLog = "FATAL ERROR";		
	}
}

function XPLogError (message)
{
	XPSysError = true;
	XPLogEntry (message, 'ERR');
}

function XPLogWarn (message)
{
	XPSysError = false;
	XPLogEntry (message, 'WARN');
}

function XPLogTrace (message)
{
	XPLogEntry (message, 'INFO');
}

function XPDetectFlash()
{
	try
	{
		var f="",n=navigator;  
		if (n.plugins && n.plugins.length)
		{  
			for (var ii=0;ii<n.plugins.length;ii++)
			{  
				if (n.plugins[ii].name.indexOf('Shockwave Flash')!=-1) 
				{ 
					f=n.plugins[ii].description.split('Shockwave Flash ')[1]; 
					i=f.indexOf('.');
					f=f.substr(0,i);   
					break;  
				}
			}
		}
		else if (window.ActiveXObject)
		{ 
			for (var ii=10;ii>=2;ii--)
			{ 
				try
				{
					var fl=eval("new ActiveXObject('ShockwaveFlash.ShockwaveFlash."+ii+"');");
					if (fl)
					{
						f=ii;
						break;
					}
				} 
				catch(e)
				{}
			}
		}
		return f;
	}
	catch (error)
	{	
		XPLogError ('F000: ' + error);	
	}
}

function XPPBCCookie ()
{
	try
	{
		if (XPCConf.config.pgbccname != null && XPCConf.config.pgbccname != "")
		{
			document.cookie =  XPCConf.config.pgbccname + '=true; expires=; path=/;';
			XPLogTrace ('PGBCaching cookie set: '+XPCConf.config.pgbccname+'=true');
		}
		else
		{
			XPLogError ('F008: No pgbcache cookie name defined. ');	
		}
	}
	catch (error)
	{	
		XPLogError ('F000: ' + error);	
	}
}