if( app ) {
	
	/**
	 * updates deletes all keys from a map object
	 * paramters:
	 * 	map : Object - manipulated
	 *  keys : Array - contains map-keys as string that should be deleted
	 * returns the manipulated map object
	 */
	app.deleteKeys = function( map, keys ) {
		for( var i=0; i<keys.length; i++ ) {
			var key = keys[i];
			delete map[key];
		}
		return map;
	}

	/**
	 * append an arguments string at the end of an url
	 * parameters:
	 * 	url : String - the base url (hash is not supported here!)
	 *  args : String/Object - the url arguments to append
	 * returns a new url string
	 */
	app.appendUrl = function( url, args ) {
		if( null==args || null==url ) {
			return url;
		}
		if( 'object'==typeof(args) ) {
			args = $.param(args);
		}
		if( ''==args ) {
			return url;
		}
		var delimiter = '&';
		if( url[ url.length-1 ]=='&' || url[ url.length-1 ]=='?' ) {
			delimiter = '';
		}
		else if( -1 == url.indexOf( '?' ) ) {
			delimiter = '?';
		}
		return url + delimiter + args;
	}
	
	/**
	 * returns a mapping object for the hash arguments of the current document
	 * 	null if no hash was specified
	 */
	app.getClientArgs = function() {
		function convertUrlArgsToHash( url ) {
			var map = {};
			$.each( url.split('&'), function() {
				var pair = this.split('=');
				map[ pair[0] ] = decodeURIComponent( pair[1] );
			} );
			return map;
		}

		var hashValue = location.hash.substr( location.hash.indexOf('#')+1 );
		if( 0==hashValue.indexOf('!') ) {
			var urlArgs = decodeURIComponent( hashValue.substr(1) );
			return convertUrlArgsToHash( urlArgs );
		}
		return null;
	}
	/**
	 * redefines the hash arguments of the current document
	 * parameters:
	 * 	clientArgs : String/Object - the new client arguments 
	 */
	app.setClientArgs = function( clientArgs ) {
		if( null==clientArgs ) {
			clientArgs = '';
		}
		else if( 'object'==typeof(clientArgs) ) {
			clientArgs = $.param( clientArgs )
		}
		document.location.hash = '#!' + encodeURIComponent( clientArgs );
	}
	
	/**
	 * updates the client arguments
	 * you can give any number of arguments
	 *   object - each key is added to the current args
	 *   array - each item is used as a key name and deleted
	 */
	app.updateClientArgs = function() {
		var clientArgs = app.getClientArgs();
		if( null==clientArgs ) {
			clientArgs = {};
		}
		for( var i=0; i< arguments.length; i++ ) {
			var arg = arguments[i];
			if( null==arg ) {
				continue;
			}
			var argType = typeof arg;
			if( 'object'==argType ) {
				if( arg instanceof Array ) {
					app.deleteKeys( clientArgs, arg );
				}
				else {
					$.extend( clientArgs, arg );
				}
			}
		}
		app.setClientArgs( clientArgs );
	}
	
	app.ProductNavigation = function( containerId, getSelectedVariant ) {
		var productKeys = [ 'i', 'color', 'size'];
		var searchPageSize = 30;

		var backUrl = null;
		var previousLinkHtml = null;
		var nextLinkHtml = null;
		
		function init() {
			var args = app.getClientArgs();
			if( null==args ) {
				return;
			}
			initBackUrl( args );
			initPreviousNextLinks( args );
			initLeftNavigation( args );
		}
		function initBackUrl( args ) {
			var backArgs = $.extend( {}, args );
			app.deleteKeys( backArgs, productKeys );
			if( 'cgid' in app.URLs.searchArgs || 'q' in app.URLs.searchArgs || 'q' in backArgs ) {
				backUrl = app.appendUrl( app.URLs.searchUrl, backArgs );
			}
		}
		function initPreviousNextLinks( args ) {
			var container = $( containerId );
			if( !('i' in args) || 0==$('.productprevious, .productnext', container).length ) {
				return;
			}
			var productIndex = parseInt( args['i'] );
			var pageIndex = productIndex % searchPageSize;

			var searchArgs = $.extend( {}, args );
			app.deleteKeys( searchArgs, productKeys );
			$.extend( searchArgs, {
				'start': productIndex-1 - pageIndex,
				'sz': searchPageSize + 2,
				'include': 'productLinkJSON'
			} )
			var productLinkJsonUrl = app.appendUrl( app.URLs.searchUrl, searchArgs );
			$.getJSON( productLinkJsonUrl, null, function(productLinks) { handleProductLinks( productLinks, args, productIndex, pageIndex ); } );
		}
		function initLeftNavigation( args ) {
			if( !('cgid' in args) ) {
				return;
			}
			var navigationArgs = $.extend( {}, args );
			app.deleteKeys( navigationArgs, productKeys );
			$.extend( navigationArgs, { 
				'include' : 'leftNavigation' 
			} );
			var leftNavigationUrl = app.appendUrl( app.URLs.searchUrl, navigationArgs );
			$( '#leftcolumn' ).load( leftNavigationUrl );
		}
		function handleProductLinks( productLinks, args, productIndex, pageIndex ) {
			var container = $( containerId );
			if( pageIndex > 0 ) {
				var previousLink = productLinks[ pageIndex ];
				var url = getLinkUrl( args, previousLink, productIndex -1 );
				var title = $('.productprevious', container ).attr('title');
				previousLinkHtml = '<a href="' + url + '" title="' + title + '"><span class="image"><!-- empty --></span><span class="text">' + title + ' </span><img alt="" src="' + previousLink.img + '"/></a>';
			}
			if( pageIndex+2 < productLinks.length ) {
				var nextLink = productLinks[ pageIndex + 2 ];
				var url = getLinkUrl( args, nextLink, productIndex +1 );
				var title = $('.productnext', container ).attr('title');
				nextLinkHtml = '<a href="' + url + '" title="' + title + '"> <img alt="" src="' + nextLink.img + '"/> <span class="text">' + title + ' </span><span class="image"><!-- empty --></span></a>';
			}
			bindEvents();
		}
		function getLinkUrl( args, link, productIndex ) {
			var urlArgs = $.extend( {}, args );
			app.deleteKeys( urlArgs, productKeys );
			urlArgs['i'] = productIndex;
			if( ''!=link.color ) {
				urlArgs['color'] = link.color;
			}
			var hashArgs = encodeURIComponent( $.param( urlArgs ) );
			return app.appendUrl( link.href, app.URLs.searchArgs ) + '#!' + hashArgs;
		}
		function bindEvents() {
			var variant = getSelectedVariant();
			if( null!=backUrl ) {
				$( '.pdpContShopLink' ).attr('href', backUrl );
			}
			else {
				$( '.pdpContShopLink' ).hide();
			}
			if( null!=previousLinkHtml ) {
				$( '.productprevious' ).html( previousLinkHtml );
			}
			if( null!=nextLinkHtml ) {
				$( '.productnext' ).html( nextLinkHtml );
			}
		}
		
		init();
		return {
			bindEvents: bindEvents
		};
	}

	app.ProductZoom = function( config ) {
		var zoomHtml;
		function init() {
			zoomHtml = $('#zoom').html();
			$('#zoom').dialog( {
	 			bgiframe: true,
	 			autoOpen: false,
				modal: true,
		    	width: 736,
		    	title: config.zoomDialogTitle,
		    	resizable: false,
		    	dialogClass: 'zoomBox'
			} );
		}
		
		function showZoomDialog() {
			$('#zoom').html( zoomHtml ).dialog('open');
			var color = app.product.getSelectedAttributes()['color'];
			var zoomUrl = app.appendUrl( config.zoomConfigUrl, 'color='+color );
			var swfParameters = {
				xmlPath: zoomUrl
			};
			var swfOptions = {
				wmode: "transparent",
				quality: "high",
				salign: "lt"
			};
			swfobject.embedSWF( config.zoomSwfUrl, "zoomSwf", "746", "457", "9", "", swfParameters, swfOptions, {} );
		}
		
		function bindEvents( image ) {
			$( '.zoombox', image ).click( showZoomDialog );
		}
		function updateImage( image ) {
			// nothing to do
		}
		
		init();
		return {
			bindEvents: bindEvents, // called for each variant when it is shown the first time
			updateImage: updateImage // called for each switch of a variant
		};
	};
	
	app.ProductRecommendations = function( config ) {
		function init() {
			app.producttile.initAll();
			$(document).bind('productVariants', initVariants );
		}
		
		function initVariants() {
			app.producttile.initAll();
		}
		
		function bindEvents( recommendations ) {
			$( '.recommendation-tabs', recommendations ).tabs();
		}
		
		function update( recommendations, old ) {
			if( !recommendations.hasClass('initialized') ) {
				bindEvents( recommendations );
				recommendations.addClass('initialized');
			}
			updateCurrentTab( old, recommendations );
		}
		
		function updateCurrentTab( oldRecommendations, newRecommendations ) {
			var oldTabs = $( '.recommendation-tabs', oldRecommendations ).tabs();
			var newTabs = $( '.recommendation-tabs', newRecommendations ).tabs();
			var index = oldTabs.tabs('option', 'selected');
			newTabs.tabs('select', index);
		}
		
		init();
		return {
			bindEvents: bindEvents, // called for each variant when it is shown the first time
			update: update // called for each switch of a variant
		};
	};
	
	app.Product = function( config ) {
		var variantAttributeKeys = { 'color':1, 'size':1 };
		var productContainerId = "#pdpMain";
		var variantContainerId = "#allVariants";
		var imagesContainerId = "#allImages";
		var recommendationsContainerId = "#allRecommendations";
		var selectedVariantAttributes = {};
		var selectedVariantID = null;
		var variantsLoaded = false;
		var navigation;
		var zoom;
		var recommendations;
		var activeImageIndex = 0;

		function init() {
			navigation = app.ProductNavigation( variantContainerId, getSelectedVariant );
			zoom = app.ProductZoom( config );
			recommendations = app.ProductRecommendations( config );
			initSelectedVariant();
			loadVariants();
		}
		function initSelectedVariant() {
			var container = $( variantContainerId );
			var variant = $( '.variant:first', container );
			selectedVariantID = variant.attr('id');
			selectedVariantAttributes = getVariantAttributes( variant );
			selectedVariantAttributes = app.Product.customizeSelectedVariantAttributesHook(selectedVariantID, selectedVariantAttributes);
			updateSelectedVariant( variant );
			updateSelectedImage( getSelectedImage() );
			
			loadlazyRecommendationImages (getSelectedRecommendations());
			recommendations.update( getSelectedRecommendations() );
		}
		function loadVariants() {
			$.ajax( {
				url : config.variantsUrl,
				success: function( text ) {
					updateHtml( text );
					variantsLoaded = true;
					initSelectedVariantClientArgs();
					updateSelectedVariant( getSelectedVariant() );
					updateSelectedImage( getSelectedImage() );
					recommendations.update( getSelectedRecommendations() );
					$(document).trigger( 'productVariants', variantContainerId );
				}
			} );
		}
		function updateHtml( text ) {
			$( productContainerId + ' .select-replacement' ).remove();
			$( productContainerId + ' .initialized' ).removeClass('initialized');
			var variantHtml = $( variantContainerId ).html();
			var imageHtml = $( imagesContainerId ).html();
			var recommendationsHtml = $( recommendationsContainerId ).html();			
			$(productContainerId)[0].innerHTML = text;
			$( variantContainerId ).append( variantHtml );
			$( imagesContainerId ).append( imageHtml );
			$( recommendationsContainerId ).append( recommendationsHtml );
		}
		function initSelectedVariantClientArgs() {
			var args = app.getClientArgs();
			if( null==args ) {
				return false;
			}
			var newVariantAttributes = $.extend( {}, selectedVariantAttributes );
			var changed = false;
			for( var key in variantAttributeKeys ) {
				if( key in args ) {
					value = args[key];
					setVariantAttribute( newVariantAttributes, key + '_' + value );
					changed = true;
				}
			}
			if( !changed ) {
				return false;
			}
			oldVariantID = selectedVariantID;
			return selectVariantAttributes( newVariantAttributes ) && oldVariantID != selectedVariantID;
		}
		function selectVariantClass( className ) {
			selectedVariantAttributes = app.Product.customizeSelectedVariantAttributesHook(selectedVariantID, selectedVariantAttributes);
			var newVariantAttributes = $.extend( {}, selectedVariantAttributes );
			setVariantAttribute( newVariantAttributes, className );
			return selectVariantAttributes( newVariantAttributes );
		}
		function getVariantClassSelector( variantAttributes ) {
			var selectors = ['.variant'];
			for( var key in variantAttributes ) {
				var value = variantAttributes[key];
				selectors.push( '.'+key+'_'+value  );
			}
			return selectors.join('');
		}
		function setVariantAttribute( variantAttributes, className ) {
			var splitIndex = className.indexOf('_');
			if( splitIndex==-1 ) {
				return false;
			}
			var key = className.substr(0, splitIndex);
			var value = className.substr(splitIndex+1);
			if( key in variantAttributeKeys ) {
				variantAttributes[key] = value;
				return true;
			}
			return false;
		}
		function getVariantAttributes( variant ) {
			var variantAttributes = {};
			if( variant.length > 0 ) {
				$.each( variant.attr('class').split(' '), function() {
					setVariantAttribute( variantAttributes, this ); 
				} );
			}
			return variantAttributes;
		}
		function findVariant( variantAttributes ) {
			var container = $( variantContainerId );
			var variant = $( getVariantClassSelector(variantAttributes)+':first', container );
			if( 0==variant.length ) {
				delete variantAttributes['size'];
				variant = $( getVariantClassSelector(variantAttributes)+':first', container );
			}
			return variant;
		}
		function findNewVariant( className ) {
			var newVariantAttributes = $.extend( {}, selectedVariantAttributes );
			setVariantAttribute( newVariantAttributes, className );
			return findVariant( newVariantAttributes );
		}
		function selectVariantAttributes( newVariantAttributes ) {
			if( variantsLoaded ) {
				var newVariant = findVariant( newVariantAttributes );
				if( newVariant.length==0 ) {
					return false;
				}
				var newVariantId = newVariant.attr('id');
				app.Product.updateProductPageHook(newVariant, newVariantAttributes);
				if( newVariantId==selectedVariantID ) {
					//webtrekk
					TrackActiveId();					
					return true;
				}
				var newVariantAttributes = selectVariantId( newVariantId );
				if( !config.isQuickView ) {
					app.updateClientArgs( newVariantAttributes );
				}
			}
			selectedVariantAttributes = newVariantAttributes;
			return true;
		}
		
		function loadlazyProductImages(color, clazz) {
			$( imagesContainerId + ' .color_' + color  + ' ' + clazz).each(function()  {
				if (!$(this).attr('src')) 
					this.setAttribute('src', this.getAttribute('data-lazyloadsrc'));
			} );
		}
		
		function loadlazyImages(color) {
			loadlazyProductImages(color, 'img.mini');
			loadlazyProductImages(color, 'img.mainImage');
			loadlazyProductImages(color, 'img.previewImage');
		}
		
		function loadlazyRecommendationImages ( recommendation ) {
			recommendation.each ( function () {					
				var imgages = $(this).find ('.productimage a img');
				imgages.each ( function () {
					if (!this.getAttribute('src'))
						this.setAttribute('src', this.getAttribute('data-lazyloadsrc'));
				});
			});			
		}
		
		
		function selectVariantId( newVariantId ) {
			var oldVariant = $( '#'+selectedVariantID ).removeClass('selected');
			var newVariant = $( '#'+newVariantId ).addClass('selected');
			
			var newVariantAttributes = getVariantAttributes( newVariant );
			var oldColor = selectedVariantAttributes['color'];
			var newColor = newVariantAttributes['color'];
			
			if( oldColor!=newColor ) {
				getSelectedImage().removeClass('selected');
				var image = $( imagesContainerId + ' .color_' + newColor ).addClass('selected');
				updateSelectedImage( image );
				
				var oldRecommendations = getSelectedRecommendations().removeClass('selected');
				var newRecommendations = $( recommendationsContainerId + ' .color_' + newColor ).addClass('selected');
				
				loadlazyRecommendationImages(newRecommendations);
				recommendations.update( newRecommendations, oldRecommendations );
			}
			
			setQuantityValue( newVariant, getQuantityValue( oldVariant ), true );
			selectedVariantID = newVariantId;
			updateSelectedVariant( newVariant );
			
			//webtrekk
			TrackActiveId();
			
			return newVariantAttributes;
		}
		function updateSelectedImage( image ) {
			if( !image.hasClass('initialized') ) {
				zoom.bindEvents( image );
				bindImageEvents( image );
				image.addClass('initialized');
			}
			updateImageIndex( image );
			zoom.updateImage( image );
		}
		function updateSelectedVariant( variant ) {
			if( !variant.hasClass('initialized') ) {
				$('.formidable', variant ).formidable();
				navigation.bindEvents();
				bindVariationEvents( variant );
				bindActionEvents( variant );
				bindAddToCartEvents( variant );
				variant.addClass('initialized');
				
				var color = getVariantAttributes( variant )['color'];
				loadlazyImages(color);
			}
			else {
				resetVariationSelect( variant );
				$('.formidable', variant ).formidable('repaint');
			}
		}
		function updateImageIndex( image ) {
			$( '.productthumbnails .thumbnail[data-index='+activeImageIndex+']', image ).each( hoverProductThumbnail );
		}
		function bindVariationEvents( variant ) {
			$( '.variantContent .swatches ul li a', variant ).click( selectVariationLink );
			$( '.variantContent .addToCartForm select', variant ).change( selectVariationInput );
//			$( '.variantContent .colorVariations .swatchesdisplay a', variant ).hover( hoverColorVariation );
//			$( '.variantContent .colorVariations .swatchesdisplay', variant ).mouseleave( leaveColorVariation );
		}
		function bindImageEvents( image ) {
			var thumbnails = $( '.productthumbnails .thumbnail', image );
			thumbnails.each( function(i) { $(this).attr('data-index', i); } );

//			thumbnails.hover( hoverProductThumbnail );
			thumbnails.click( hoverProductThumbnail );
		}
		function bindActionEvents( variant ) {
			$( '.sendtofriend', variant ).click( function() {
				app.dialog.open( config.sendToFriendUrl, app.resources.SEND_TO_FRIEND);
				return false;
			} );
			$( '.addtowishlist a', variant ).click(function(e) {
				var url = $(this).attr('href');
				var quantity = getQuantityValue( variant );
				if( 0 >= quantity ) {
					return false;
				}
				args = { Quantity: quantity };
				window.location.href = app.appendUrl( url, args );
				return false;
			} );
			$('.bisn', variant).click(function() {
				app.dialog.openResized(config.bisnUrl, app.resources.BISN, 800, 450);
				return false;
			});
		}
		function bindAddToCartEvents( variant ) {
			$( '.variantContent .quantityinput', variant ).keyup( changedQuantity );
			
			$( '.variantContent .addtocartbutton', variant ).click( addToCart );
		}
		function resetVariationSelect( variant ) {
			$( '.variantContent .sizeVariations select.size', variant ).each( function() {
				var self = $(this);
				var defaultValue = self.attr('data-defaultvalue');
				self.val( defaultValue );
			});
		}
		function selectVariationLink() {
			if( $(this).parents('.disabledswatch').length > 0 ) {
				if( ('soldOutMessage' in config) ) {
					window.alert( config.soldOutMessage );
				}
				return false;
			}
			var href = $( this ).attr('href');
			var className = href.substr( href.indexOf('#')+1 );
			var wasSelected = selectVariantClass( className );
			if( !wasSelected && ('soldOutMessage' in config) ) {
				window.alert( config.soldOutMessage );
			}
			return false;
		}
		function selectVariationInput() {
			var className = $( this ).val();
			selectVariantClass( className );
		}
		function hoverProductThumbnail() {
			var image = getSelectedImage();
			$( '.productthumbnails .thumbnail.active', image ).removeClass('active');
			var self = $( this ).addClass('active');
			var imageUrl = self.attr( 'data-detailurl' );
			var imageIndex = self.attr( 'data-index' );
			$( '.productimage img.mainImage', image ).attr( 'src', imageUrl );
			activeImageIndex = imageIndex;
		}
		function hoverColorVariation() {
			var href = $( this ).attr('href');
			var className = href.substr( href.indexOf('#') + 1 );
			
			var splitIndex = className.indexOf('_');
			if( splitIndex==-1 ) {
				return false;
			}
			var color = className.substr(splitIndex+1);
			loadlazyImages(color);
			
			var previewImage = $( imagesContainerId + ' .colorImages.' + className );
			$( imagesContainerId + ' .colorImages.previewed' ).removeClass('previewed');
			previewImage.addClass('previewed');
			if( !previewImage.hasClass( 'selected' ) ) {
				$(productContainerId).addClass( 'preview' );
			}
		}
		function leaveColorVariation() {
			$( productContainerId ).removeClass( 'preview' );
			$( imagesContainerId + ' .colorImages.previewed' ).removeClass('previewed');
		}
		
		function changedQuantity() {
			try {
				var quantity = parseInt( $(this).val() );
				setQuantityValue( getSelectedVariant(), quantity );
			} catch(e){
				val = null
			};
		}
		
		function addToCart() {
			var variant = getSelectedVariant();
			var addToCartButton = $( '.variantContent .addtocartbutton', variant );
			if( !addToCartButton.hasClass('active') || addToCartButton.attr('disabled') ) {
				return false;
			}

			var container = $( variantContainerId );
			var masterId = container.attr( 'data-productid' );
			var maxQuantity = parseInt( $( this ).attr( 'data-maxquantity' ) );
			var variantId = getVariantProductId( variant );
			var quantity = getQuantityValue( variant );
			if( quantity <= 0 || quantity > maxQuantity ) {
				return false;
			}
			var args = {
				masterPid: masterId,
				pid: variantId,
				Quantity: quantity
			};
			
			addToCartButton.attr( 'disabled', true );
			if (typeof(pageTracker)!="undefined") {
				pageTracker._trackEvent('Basket', 'Product added');
			}
			
			if( ("AddToCart" in $.event.global) && null!=$.event.global["AddToCart"] ) {
				var ev = $.Event("AddToCart");
				ev.args = args;
				$(document).trigger( ev );
			}
			else {
				app.minicart.add( "", args, function(){ addToCartButton.removeAttr("disabled"); } );
			}
			return false;
		}
		function getVariantProductId( variant ) {
			var id = variant.attr('id');
			var index = id.indexOf('_');
			return id.substr( index + 1 );
		}
		function getQuantityValue( variant ) {
			try {
				var quantity = $( '.variantContent .quantityinput', variant ).val();
				var quantityValue = parseInt( quantity );
				if( isNaN(quantityValue) ) {
					return 1;
				}
				return quantityValue;
			}
			catch(e) {
				return 1;
			}
		}
		function setQuantityValue( variant, quantityValue, force ) {
			if( force ) {
				quantityValue = ('number'==typeof quantityValue && !isNaN(quantityValue)) ? Math.max( 1, quantityValue ) : 1;
				$( '.variantContent .quantityinput', variant ).val( quantityValue );
			}
			updateAvailability( variant, quantityValue );
		}
		function updateAvailability( variant, quantityValue ) {
			var addToCartButton = $( '.variantContent .addtocartbutton', variant );
			var maxQuantity = parseInt( addToCartButton.attr( 'data-maxquantity' ) );
			var orderable = quantityValue > 0 && quantityValue <= maxQuantity;
			if( orderable ) {
				addToCartButton.removeAttr( 'disabled' ).removeClass( 'disabled' );
			}
			else {
				addToCartButton.attr( 'disabled', true ).addClass( 'disabled' );
			}
		}
		
		function getSelectedVariant() {
			var variant = $( '#'+selectedVariantID );
			return variant;
		}
		function getSelectedImage() {
			return $( imagesContainerId + ' .colorImages.selected' );
		}
		function getSelectedRecommendations() {
			return $( recommendationsContainerId + ' .variantRecommendations.selected' );
		}
		function getSelectedAttributes() {
			return selectedVariantAttributes;
		}
		function getActiveVariantId(){			
		   var SelectedVariant = getSelectedVariant();
		   var VariantId = SelectedVariant.attr('id').split("_")[1];
		   return VariantId;
		} 
		function TrackActiveId() {
			var newVariantId = getActiveVariantId();
			var url = webtrekkUrl + "?wtTrackingType=swatchtracking&variantid=" + newVariantId + "&currcatgid=-1";//+currCatgID;
			
			getWebtrekkJSONObj(url, function(data){
		    	app.webtrekk.trackingHandler(data);
		   });
		}
		
		/* used for product recommendations in producttile-include.isml */
		function trackAndRedirect(currentStyle, crossid, targetUrl) {
			
			//debugger;
			if(typeof(wt_sendinfo) != "undefined") {
				var wtUrl = webtrekkUrl.toString() + "?wtTrackingType=clickcrosssell&crossSellID=" + crossid + "&mainProductId="+currentStyle;
				
				$.getJSON(wtUrl, function(data){
					//debugger;
					app.webtrekk.trackingHandler(data);
					document.location.href = targetUrl;
				});
			} else {
				document.location.href = targetUrl;
			}
		}
		
		init();
		app.product = {
			selectVariantClass: selectVariantClass,
			selectVariantId: selectVariantId,
			getSelectedVariant: getSelectedVariant,
			getSelectedAttributes: getSelectedAttributes,
			trackActiveId: TrackActiveId,
			trackAndRedirect:trackAndRedirect,
			bindImageEvents: bindImageEvents
		};
	};
	
	//
	// This hook function may be overwritten client-specific outside of this file
	//
	// This function makes it possible to read additional information from the Product Detail Page to selectedVariantAttributes.   
	//
	app.Product.customizeSelectedVariantAttributesHook = function(selectedVariantID, selectedVariantAttributes){
		// Do nothing, can be overwritten.
		return selectedVariantAttributes;
	}

	//
	// This hook function may be overwritten client-specific outside of this file
	//
	// This function makes it possible to update Product Detail Page for selected variant with the information from variantAttributes variable. 
	//
	app.Product.updateProductPageHook = function(variant, variantAttributes){
		// Do nothing, can be overwritten.
	}
	
}
else {
	// dw namespace has not been defined yet i.e. app object is unavailable
	alert("app is undefined!");
}