

/* hned vytvarime pole pro seznam funkci, ktere se maji skustit pri zmene stavu dokumentu. Nemuzeme je vytvaret az v knihovne binargon, protoze v IE7 a IE8 to nejde */
var binargon_onCommplete = binargon_onCommplete || [],
		binargon_onInteractive = binargon_onInteractive  || [],
		binargon_onLoaded = binargon_onLoaded || [],
		binargon_onLoading = binargon_onLoading  || [],
		binargon_onUninitialized = binargon_onUninitialized  || [];

(function(){

	var binargon = window.binargon = new function(){

		/* REGULARNI VYRAZY */
		var regFloat = 	new RegExp('(?:[-]{0,1}[1-9]+[0-9]*[,.]{0,1}[0-9]*)|(?:[-]{0,1}[0]*[,.]{1}[0-9]*)', '');
	  var regMezera = new RegExp(' ', '');
		var regMezeraGlobal = new RegExp(' ', 'g');

		// ORIZNE HODNUT dle MIN a MAX
		function clamp(min, val, max){
      return Math.min(Math.max(val, min), max)
		}

		this.clamp = clamp;


		// VRATI JSON s udaji z DATA-BINARGON
		function getMetaBinargonJSON(){
			var vysl = {
				"fce":"1",
				"id":"0",
				"menaId":"1",
				"menaName":"Kč",
				"languageCode":"cs-CZ",
				"skindir":"",
				"cmslang":"1"
			};

      var source = document.querySelector('meta[data-binargon]');
      if(source != null){
				source = source.getAttribute('data-binargon');
				if(source != null){
					try{
						source = JSON.parse(source);
						Object.keys(source).forEach(key=>{
							vysl[key] = source[key].toString(); // zaznam bude vzdy string
						})
					}catch(err){}
				}
			};
			return vysl;
		}

		this.getMetaBinargonJSON = getMetaBinargonJSON;



		// vrati aktualni menu
    this.getCurrency = function(){
			var json = getMetaBinargonJSON();
			return {
				"id": parseFloat(json.menaId),
				"name": json.menaName
			};
		}

		/* vraci jazyk, v jakem bezi aktualni stranka */
		this.getLanguage = function(){
      
			var metaData = getMetaBinargonJSON();
			var languageCode = metaData.languageCode.split('-');
			var zkratka = (languageCode.length == 2) ? languageCode[0] : 'cz';

			if(zkratka == 'cs'){
				zkratka = 'cz';
			}

			return {
				"id": metaData.cmslang,
				"zkratka": zkratka,
				"languageCode": metaData.languageCode
			};

		}

		this.getSkin = function(){
			return {
				"name": getMetaBinargonJSON().skindir
			};
		}
		
		function getCookie(key){
			var c = document.cookie.split(/\s*;\s*/);
			for(var i=0; i<c.length; i++){
				c[i]=c[i].split('=');
				if(c[i].length==2 && c[i][0]==key){
					return c[i][1];
				}
			}
			return null;
		}
		
		this.getCookie=getCookie;
		
		
		// ttl se zadava v milisekundach
		function setCookie(key, value, ttl, path){
			
			switch(myTypeOf(key)){
				case 'string': break;
				case 'number': key = key.toString();
				default: return; break; /* klic je povinny udaj */
			}
			
			switch(myTypeOf(value)){
				case 'string': break;
				case 'number': value=value.toString(); break;
				default: value = ''; break;
			}
			
			switch(myTypeOf(ttl)){
				case 'number': 	ttl = Math.max(0, Math.round(ttl)); break;
				case 'string': 	ttl = Math.max(0, Math.round(parseFloat(ttl))); break;
				default: 				ttl = ''; break;
			}
			
			if(ttl != ''){
				var date = new Date(); 
				ttl = date.setTime(date.getTime() + ttl); 
				ttl = ';expires=' + date.toGMTString();
			}
			
			switch(myTypeOf(path)){
				case 'string': 	path = ';path='+path.split(';').join(''); break;
				default: 				path = ';path=/'; break;
			}
			
			document.cookie = key + '=' + value + ttl + path;
		}
		
		this.setCookie = setCookie;

		
		function deleteCookie(key){
			document.cookie = (key.toString())+'=; expires=Thu, 01 Jan 1970 00:00:00 UTC;';
		}
		
		this.deleteCookie = deleteCookie;
		
		
		function addClass(obj, className){
			if(myTypeOf(obj)=='domNode' && myTypeOf(className)=='string' && className.length>0){
				obj.classList.add(className);
				/*
				var p = obj.className.split(/\s+/);
				if(p.indexOf(className)==-1){
					p.push(className);
					obj.className = p.join(' ');
				} */
			}
		}
		
		this.addClass = addClass;
		
		/* odstrani CSS tridu z objektu*/
		function removeClass(obj, className){
			if(myTypeOf(obj)=='domNode' && myTypeOf(className)=='string' && className.length>0){
				obj.classList.remove(className);
				/*
				var p = obj.className.split(/\s+/);
				while(p.indexOf(className) != -1){
					var x = p.splice(p.indexOf(className),1);
				}
				obj.className = p.join(' ');
				*/
			} 
		}
		
		this.removeClass = removeClass;
		

		// TYPE OF
		// vrati typ elementu zadaneho do prvniho parmetru
		// do druheho parametru jde zadat string, nebo funkci vracejici string. Tento string je cesta danym objektem. Muzu tak zkontrolovat, jaky tym ma cesta objekt.property.dalsi.neco.vnoreneho je number. Pokud je zadana nevalidni cesta, vraci se undefined (protoze proste takova hodnota neni nadefinovana)
		function myTypeOf(attr, path){

			function checkIfIsArray(attr){
				// normalni pole
				if(attr instanceof Array){return true;}
				if('isArray' in Array && Array.isArray(attr)==true){return true;}
		    if(Object.prototype.toString.call(attr) == '[object Array]'){return true;}
				return false;
			};

			// specialni typy
			function checkSpecialObjectTypes(attr){
				if(attr instanceof RegExp){return 'RegExp'}
				if(window!=undefined && window!=null && ('constructor' in window) && (attr instanceof window.constructor)){return 'window';}
				return 'object';
			}

			// typovana pole jsou ve skutecnosti OBJEKTY, ktere maji PODOBNE metody jako Array. V jejich případě tedy nesím vrátit, že se jedná o Array, protože mají jiné metody!
			function checkIfISTypedArray(attr){
				var typedArrayClases = ['Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array'];
				for(var i=0; i<typedArrayClases.length; i++){
					if(typedArrayClases[i] in window && attr instanceof window[typedArrayClases[i]]){
						return typedArrayClases[i];
					}
				}
				return false;
			}

			// pokud je attribut null, rovnou vratim 'null', protoze null nejde nijak prochazet, ani se ptat na jeho hodnoty
			if(attr === null){return 'null';}

			if(path != null){
				// vytvorim cestu, ktera se ma kontrolovat (defaultne null)
				switch((typeof path).toLowerCase()){
					case 'string':		path = path.split('.');	break;
					case 'function': 	path = (path()).toString().split('.'); break;
					default:					path = null; 	break;		// jestli neni zadana cesta, nastavim ji na null.
				}

				// TODO pridat podporu pro jine nez teckove zapisy? tedy neco['prvy']['druhy']
				if(path != null){
					for(var i=path.length-1; i>=0; i--){
						if(path[i].length==0){ // TODO: nemela by se kontrolovat delka, ale regularni vyraz? Otazka je, zda muzou byt v nazvu property treba procenta
							path.splice(i,1); // vyhodim prazdne zaznamy
						}
					}

					for(var i=0; i<path.length; i++){
						//if(attr.hasOwnProperty(path[i])){ // hasOwnProperty nekontroluje v prototypu. Melo by byt pouzito IN
						if((typeof attr).toLowerCase() == 'object' && path[i] in attr){ //používá se IN místo hasOwnProperty, protoze hasOwnProperty nehledá v prototypu.
							attr = attr[path[i]];
						}else{
							return 'undefined'; // pokud objekt nema danou vlastnos, vracim typ undefined, protoze cesta vede k nedefinovane property daného objektu.
						}
					}
				}

				// po tom, co jsem prosel celou path musim znova zkontrolovat, zda neny attr typu null
		    if(attr === null){return 'null';}

			}

			switch((typeof attr).toLowerCase()){
				case 'undefined':
		      return 'undefined';
				break;
				case 'object':
					// pole
	        //console.log('JE TO', typeof attr, attr);
					if(checkIfIsArray(attr)==true) return 'array';
	        //console.log('JE TO', typeof attr, attr);
					//console.log('TED2',attr, typeof attr);
					if(attr instanceof Event || ('hasOwnProperty' in attr && attr.hasOwnProperty('originalEvent'))){
						return 'event';
					}
	        // typovana pole
					var typedArray = checkIfISTypedArray(attr);
					if(typedArray != false){return typedArray};
					// domNode
					if('nodeType' in attr && attr.nodeType == 1) return 'domNode';
          if('nodeType' in attr && attr.nodeType == 11) return 'documentFragment';
					// node list
					if(attr instanceof NodeList){ return 'nodeList'; }
          // zbyle mozne typy
					return checkSpecialObjectTypes(attr);
				break;
		    case 'function':
		      return 'function';
				break;
				case 'boolean':
		      return 'boolean';
				break;
				case 'number':
					if(isNaN(attr)){return 'NaN';}
					// if(!isFinite(attr)){return 'infinity'} NEKONECNO NERESIME, protoze s nim jde pocitat jako s normalnim cislem?
		      return 'number';
				break;
				case 'symbol':
		      return 'symbol';  /* new in ECMAScript 2015 */
				break;
				case 'string':
					return 'string';
				break;
				default:
		      if(checkIfIsArray(attr)==true) return 'array';
				break;
			}

			return '';

		}
		
		this.typeOf = myTypeOf;
		

		/* kontrola, zda je zadany argument pole */
		this.isArray = function(arg){
			if(arg instanceof Array){return true;}
			if('isArray' in Array && Array.isArray(arg)==true){return true;}
      if(Object.prototype.toString.call(data) == '[object Array]'){return true;}
			return false;
		}

		/* vyparsuje float.. pokud to nedokaze(neni to cislo) tak vrati nulu */
		this.parseFloat = function(str, ignorovatMezery){
			
			/* kontrola typu */
			switch(myTypeOf(str)){
				case 'string':
          /* string se bude dale zpracovavat */
				break; 
				case 'number':
					//if(isNaN(str)){return 0;} return str;
					if(isNaN(str)){return 0;} 						/* pokud je NaN tak vracim nulu */
					if(str == -0){return 0;}    					/* neni to nutne matematicky, ale protoze se muze cislo nekde dale prevadet na string, kontroluji i zapornou nebo kladnou nulu */
					return str;														/* jinak se jedna skutecne o cislo a vracim str, protoze je to proste cislo */
				break; 
				default:
					return 0;
				break; /* ve vsech ostatnich pripadech vrati nulu */
			}

			/* pokud mam ignorovat mezery, tak je ze stringu odstranim... kdyz prijde '1 0.5', tak to beru jako '10.5' */
			if(ignorovatMezery==true) str = str.replace(regMezeraGlobal,'');

	    var value = regFloat.exec(str);

			if(value!=null && value.length>0){
				var value1=value[0].replace(',','.');
				if(value1.indexOf('.')==0){value1 = '0'+value1;} 				/* kdyz string zacina na desetinou tecku, tak PRED neho pridam nulu */
				if(value1.indexOf('.')==value1.length-1){value1+='0';} 	/* kdyz string konci na desetinou tecku, tak ZA neho pridam nulu */
				var value2 = parseFloat(value1)*1;
				return value2;
			}

			return 0;
		}
		
		//this.parseFloat = parseFloat; NE NE NE, musi to byt prez this, protoze jinak prepisu standardni funkci parseFloat!

		// NAFORMÁTUJE VSTUP JAKO CENU (1 234.50)
		function formatPrice(value, pocetDesetinnychMist, oddelovacTisicu, zaokrouhlit, odstranitNuly, oddelovacDesetin){

			// cislo, ktere chci naformatovat
			var value = myParseFloat(value, false);

			// pocet desetinnych mist, ktere ma mit vysledek (defaultně 2)
      var pocetDesetinnychMist = (pocetDesetinnychMist!=undefined && pocetDesetinnychMist==parseInt(pocetDesetinnychMist,10)) ? parseInt(pocetDesetinnychMist,10) : 2;

			// oddělovač tisíců (defaultně mezera)
	    var oddelovacTisicu = (oddelovacTisicu!=undefined && oddelovacTisicu.toString()==oddelovacTisicu)? oddelovacTisicu.toString() : ' ';

			// ma se vysledek zaokrouhlit?
	    var zaokrouhlit = (zaokrouhlit===false) ? false : true;

			// oddělovač desetin desetiny jsou defaultně odděleny tečkou
      var oddelovacDesetin = (oddelovacDesetin!=undefined && oddelovacDesetin.toString()==oddelovacDesetin) ? oddelovacDesetin.toString() : '.';

			// maji se odstranit nuly? (defaultne se odstranuje 00)
			var odstranitNuly = odstranitNuly;

      //odstranitNuly = (odstranitNuly===false)? false: true;
			switch(odstranitNuly){
				case true: 	break;                      // nuly se budou odstranovat
				case false: break;  										// nuly se nebudou odstranovat
				default: odstranitNuly = '00'; break; 		// nuly odstrani jen pokud jsou by cislo koncilo na '.00'
			}
			/*
			switch(odstranitNuly){
				case '00': 	break;                      // nuly odstrani jen pokud jsou by cislo koncilo na '.00'
				case false: break;  										// nuly se nebudou odstranovat
				default: odstranitNuly = true; break; 	// nuly se budou odstranovat
			}*/

			// zkontroluji, ze pocet desetinnych mist je v rozmezi 0 az 14
	    pocetDesetinnychMist = Math.min(Math.max(pocetDesetinnychMist, 0), 14);

			// zazalohuju si pocet desetinnychmist
			var zalohaPoctuDesetinnychMist = pocetDesetinnychMist;

			// vprevedu na nasobic ... kdyz mi prijdou 2, tak je vysledek 100 ... protoze potrebuju pridat 2 mista, nasobim stovkou
	    pocetDesetinnychMist = Math.pow(10, pocetDesetinnychMist);

			// cislo zaokrouhlim na zadany pocet desetinnych mist
			if(zaokrouhlit){value = Math.round(value * pocetDesetinnychMist) / pocetDesetinnychMist ;}

			// naformatovani poctu desetinnych mist + rozdeleni podle desetinne tecky
			value = value.toFixed(zalohaPoctuDesetinnychMist).split('.');

			// dale se s value pracuje jako s polem dvou stringu. V jedne casti je cela cast a v druhe desetinna cast
			//value = value.toString().split('.');


      // jesli ma cislo i desetinnou cast, zkontroluji, zda se nema osetrit
			if(value.length > 1){
				switch(odstranitNuly){
          // pokud se ma na konci odstranit dvojit nula '.00' tak ji odstranim.
					case '00':
            if(value[1]=='00'){value.splice(1);}
					break;
          // pokud ma cislo desetiny a mam zapnuto odstranovani nul z desetinne casti (napr. aby cislo nekoncilo .00) tak nuly odstranim
					case true:
						// od konce najdu pozici, na ktere se vyskytuje nula
						var pozicePosledniNuly = null;
						for(var i = value[1].length-1; i>=0; i--){
							if(value[1].substr(i,1) == '0'){
		            pozicePosledniNuly = i;
							}else{
								break;
							}
						}

						// nuly na konci desetinne casti ze stringu odriznu
						if(pozicePosledniNuly != null){value[1] = value[1].substr(0,pozicePosledniNuly);}

						// z pole odstrain desetinnou cast, pokud je prazdna, (jinak by se za cislem vypsala desetinna tecka)
						if(value[1].length==0){value.splice(1);}

					break;
				}
			}

			// kolik znaku se musi odriznout od zacatku? 50 000 = 2 znaky, 500 00 = 3 znaky
			var nadbytek = (value[0].length>3) ? value[0].length % 3 : 0;

			return	((nadbytek>0) ? value[0].substr(0,nadbytek)+oddelovacTisicu : '') + // prvni cast retezce, ktery ma mene znaku nez 3
							value[0].substr(nadbytek).replace(/(\d{3})(?=\d)/g, '$1' + oddelovacTisicu) + // zbytek cele casti s oddelenyma tisicema
							((value.length >= 2)? (oddelovacDesetin + value[1]) : ''); // desetinna cast
		}

		this.formatPrice = formatPrice;


		/* prirazeni posluchace udalsoti */
		// 0 skinu, ktere by to pouzivalo, 0 knihoven, ktere by to pouzivalo
		this.addEvent = function(elm, evType, fn, useCapture) {
			if(elm.addEventListener){
				elm.addEventListener(evType, fn, useCapture); return true;
			}else if(elm.attachEvent){
				var r = elm.attachEvent('on'+evType, fn); return r;
			}
		}

		/* vrati status dokumentu, prelozi nazev na poradove cislo (nekdy potrebuju porovnavat, ze stav je vetsi nez X, nebo je v rozsahu X-Y) */
		function getReadyState(){
      switch((document.readyState).toString().toLowerCase()){
				case 'uninitialized': 	return 1; break;
				case 'loading': 				return 2; break;
				case 'loaded': 					return 3; break;
				case 'interactive': 		return 4; break;
				case 'complete': 				return 5; break;
			};
		}

		function zpracujAktualniStavDokumentu(){

			var state = getReadyState();
			var seznamUkolu = [];
			/* bez BREAKu! pokud nastal stav 5, je treba aby se zpracovaly i pozadavky z udalosti 4 atd... */
			switch(state){
        case 5: seznamUkolu.push(zpracuj_binargon_onCommplete);
        case 4: seznamUkolu.push(zpracuj_binargon_onInteractive);
        case 3:	seznamUkolu.push(zpracuj_binargon_onLoaded);
        case 2: seznamUkolu.push(zpracuj_binargon_onLoading);
				case 1:	seznamUkolu.push(zpracuj_binargon_onUninitialized);
				break;
			}
			/* ukoly se musi provest v opacnem poradi, nez v jakem byly do pole pridany, takze pole otocim */
			seznamUkolu.reverse();
			/* jednotlive ukoly provedu */
			for(var i=0; i<seznamUkolu.length; i++){
				seznamUkolu[i]();
			}
		}

		/* vyvori seznam, do ktereho jdou pridavat funkce, ktere se maji zavolat ihned, kdyz se dokument preklopi do urciteho stavu (napr. vsechny funkce, ktere se maji zavolat kdyz se dokument dostane do stavu 'loaded' nebo 'complete') */
		function vytvorObjektProFrontuPosluchacuStavuDoukmentu(nazevObjektu, cisloStavu){
			/* programator muze ve skinu jiz seznam zalozit a plnit, i kdyz se tato knihovna jeste nenacetla. Plni jej do obycejneho pole. Ja pak toto pole vezmu a predelam ho na objekt. */
			var seznam = (nazevObjektu in window)? window[nazevObjektu]:[];
			/* vrati delku seznamu */
			this.length = function(){
				return seznam.length;
			}
			/* prida do seznamu novy kod, ktery se ma zavolat */
			this.push=function(zaznam){
				var state = getReadyState();
				if(zaznam!=undefined && zaznam!=null){
					seznam.push(zaznam);
					/* pokud je stav dokumentu vetsi nez X, tak rovnou pozadam o zpracovani celeho seznamu (napr. pridam kod, ktery se ma spustit po nacteni dokumentu, ale dokument uz je nacteny vice jak 5 minut... provede se tedy hedn po pridani) */
					if(state>=cisloStavu){
						
						//this['zpracuj_'+nazevObjektu]();
						switch(nazevObjektu){
							case 'binargon_onCommplete':			zpracuj_binargon_onCommplete(); break;
							case 'binargon_onInteractive':    zpracuj_binargon_onInteractive(); break;
							case 'binargon_onLoaded':         zpracuj_binargon_onLoaded(); break;
							case 'binargon_onLoading':        zpracuj_binargon_onLoading(); break;
							case 'binargon_onUninitialized':  zpracuj_binargon_onUninitialized(); break;
						}
					}
				}
			}
			/* smaze seznam, ale vrati pole se seznamem prvku, ktere smazal */
			this.spliceAll=function(){
				return seznam.splice(0, seznam.length);
			}
		}

		/* funkce, ktere se maji zpracovat, pokud se dokument dostane do urciteho stavu. Napr. zpracuj_binargon_onCommplete se zavola, kdyz s doklument dostane do stavu 'commplete' */
		function zpracuj_binargon_onCommplete()			{var seznam = binargon_onCommplete.spliceAll(); 			for(var i=0; i<seznam.length; i++){(seznam[i])();}}
		function zpracuj_binargon_onInteractive()		{var seznam = binargon_onInteractive.spliceAll(); 		for(var i=0; i<seznam.length; i++){(seznam[i])();}}
		function zpracuj_binargon_onLoaded()				{var seznam = binargon_onLoaded.spliceAll(); 					for(var i=0; i<seznam.length; i++){(seznam[i])();}}
		function zpracuj_binargon_onLoading()				{var seznam = binargon_onLoading.spliceAll(); 				for(var i=0; i<seznam.length; i++){(seznam[i])();}}
		function zpracuj_binargon_onUninitialized()	{var seznam = binargon_onUninitialized.spliceAll(); 	for(var i=0; i<seznam.length; i++){(seznam[i])();}}

		/* prepise pole binargon_onCommplete na objekt */
    var binargon_onCommplete = 					window.binargon_onCommplete = 			new vytvorObjektProFrontuPosluchacuStavuDoukmentu('binargon_onCommplete', 5);
    var binargon_onInteractive = 				window.binargon_onInteractive = 		new vytvorObjektProFrontuPosluchacuStavuDoukmentu('binargon_onInteractive', 4);
    var binargon_onLoaded = 						window.binargon_onLoaded = 					new vytvorObjektProFrontuPosluchacuStavuDoukmentu('binargon_onLoaded', 3);
    var binargon_onLoading = 						window.binargon_onLoading = 				new vytvorObjektProFrontuPosluchacuStavuDoukmentu('binargon_onLoading', 2);
    var binargon_onUninitialized = 			window.binargon_onUninitialized = 	new vytvorObjektProFrontuPosluchacuStavuDoukmentu('binargon_onUninitialized', 1);

		/* spusti posluchac udalosti pro readystatechange */
		this.addEvent(document, 'readystatechange', zpracujAktualniStavDokumentu, false);





		// pouziva se v productDetail class

    /* DOBRE: http://www.xmlshop.cz/imagegen.php?name=p18-6-2-7-1/2.png&sizex=-1&sizey=-1 */
		/* MOJE:	http://www.xmlshop.cz/imgcache/3/3/pnone_-1_-1_4187.jpg */
		/* prida do URL zadane parametry a vrati je. URL muze byt string nebo pole, params musi byt json */
		function createURL(url, params){

			function addParamsToURLString(originalUrl, paramsString, char_andType){
				var url = originalUrl.toString().toLowerCase();

				// prazdne url, vratim jen parametry
				if(url.length == 0){
					return '?' + paramsString;
				}

				// kdyz konci na &amp;
				if(url.length>=5 && url.substr(url.length-5,5)=='&amp;'){
					return originalUrl + paramsString;
				}

				// kdyz konci na jeden z vyjmenovanych znaku
				switch(url.substr(url.length-1,1)){
					case '/': return originalUrl + '?' + paramsString; break;
          case '?':
          case '&': return originalUrl + paramsString;  break;
				}

				// pokud ma otaznik nebo and a pritom to neni posledni znak url (to by spadlo do predchozich podminek)
				if(url.indexOf('?') != -1 || url.indexOf('&') != -1){
          return originalUrl + char_andType +paramsString;
				}

				// v ostatnich pripadech stringy proste spojim
				return originalUrl + '?' + paramsString;

			}

			function paramsToArray(params){
				var vysl = [];
				for(var i in params){
					var key = encodeURIComponent(i);
					var value = (params[i]!=undefined && params[i]!=null) ? encodeURIComponent(params[i].toString()) : '';
					vysl.push(key + '=' + value);
				}
				return vysl;
			}

      var char_andType = '&';
			var paramsArray = (myTypeOf(params)=='object') ? paramsToArray(params) : [];

			switch(myTypeOf(url)){

				case 'array':
					for(var i=0; i<url.length; i++){
						if(myTypeOf(url[i])==string){
              char_andType = (url[i].indexOf('&amp;')!=-1) ? '&amp;' : '&';
							url[i] = addParamsToURLString(url[i], paramsArray.join(char_andType), char_andType);
						}
					}
					return url;
				break;

				case 'string':
          char_andType = (url.indexOf('&amp;')!=-1) ? '&amp;' : '&';
					return addParamsToURLString(url, paramsArray.join(char_andType), char_andType);
				break;

			}

			return url;


		}

		this.createURL = createURL;

		// TODO: safari uz zrejme umoznuje ulozit az 5MB v local storage, tento test zrejme jiz nebude nutny. NEVIM ale, zda se to tyka i iOS (https://support.apple.com/guide/safari/give-more-space-to-website-databases-sfri20879/mac)
		/* TEST LOCAL STORAGE, kvuli anonymnimu modu na iOS je potřeba otestovat i to, zda do nej jde zapsat, ne jen zda je k dispozici */
		function isLocalStorageAvailable(){
			if('localStorage' in window && localStorage != undefined && localStorage != null){
        //var testString = 'binargon test 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789';
        var testString = 'binargon test ';
				// vyplnime 300 znaku, aby byl testovaci string dlouhy;
				for(var i=0; i<300; i++){
          testString += 'X';
				}
				var testKey = '_binargon_testLocalStorage';
				try{
          localStorage[testKey] = testString;
          if(localStorage[testKey] == testString){
						localStorage[testKey] = 'test probehl uspesne';
						return true; /* pokud slo do localStorage zapsat, vratim true */
					}
				}catch(err){}
			}
			return false;
		}

		this.isLocalStorageAvailable = isLocalStorageAvailable;
		
		
		
		/* escapuje string pro vlozeni do XML (ci XHML) (v adminu je tato funkce pod jmenem escapeXML();) */
		function stringifyForXML(t){
			switch(myTypeOf(t)){
				case 'object':
					t = JSON.stringify(t);
				break;
				case 'string':
				case 'number':
				case 'boolean': 
				case 'array':
					t=t.toString();
				break;
				default:
					return '';
				break;
			}

		  t=t.replace(/&/g,'&amp;');
			t=t.replace(/"/g,'&quot;');
			t=t.replace(/>/g,'&gt;');
			t=t.replace(/</g,'&lt;');
			t=t.replace(/'/g,'&#39;');
			return t;
		}
		
		this.stringifyForXML = stringifyForXML;
		
		
		function log(string, format){
      console.log(string, format);
		}

		this.log = log;



	
		// pouzivaji metoddy ze sekce math
		function mathParameterType(a){
			var cislo = a;
			var ok = true;
			switch(myTypeOf(a)){
				case 'object': 																									break;
				case 'string': 	cislo = myParseFloat(a); 	ok = isFinite(a);			break;
				case 'number': 	cislo = a;								ok = isFinite(a);			break;
				default:				 													ok = false; 					break;
			};
			return {
				"cislo": 	cislo,
				"ok": 		ok
			};
		}
	
	
		// pouziva to funkce presne nasobeni, presne deleni
		function mathOperation(operation, cisla){
	
			// najdu si vsechna cisla
			var ok 			= true;
			var vysl 		= NaN;
			var pocetMist = [];
			
			// zkontroluju kazde cislo, ktere mi prislo
			for(var i=0; i<cisla.length; i++){
				cisla[i] = mathParameterType(cisla[i]);
				if(cisla[i].ok == false){
					ok = false;
				}
			}
			
			// spocitam vysledek pro danou operaci (napr. vsechna cisla vynasobim nebo vydelim)
			if(cisla.length > 1){
				vysl = cisla[0].cislo;
				for(var i=1; i<cisla.length; i++){
					switch(operation){
						case '+': 	vysl += cisla[i].cislo;		break;
						case '-': 	vysl -= cisla[i].cislo;		break;
						case '*': 	vysl *= cisla[i].cislo;		break;
						case '/': 	vysl /= cisla[i].cislo;		break;
					}
				}
			}
			
			//console.log('cisla', cisla, vysl);
			
			// pokud byly vsechna zadana cisla skutecne cisla, a zaroven je vysledek konecne cislo (neni periodicke) udelam presny vysledek a vratim jej 
			if(ok && isFinite(vysl)){
				pocetMist = vysl.toString().split('.');
				pocetMist = (pocetMist.length == 2) ? pocetMist[1].length : 0;
				//if(pocetMist > 14){pocetMist = 14;} // PROBLEM: nepresnost nevznika zvdycky na patnactem miste Např. 963*0.1 = 96.30000000000001 = 14 mist   ALE 0.7 / 0.1 =  6.999999999999999 = 15 mist!
				if(pocetMist > 10){pocetMist -= 1;} // oriznu posledni misto. Je to prasarna, ale: nepresnost nevznika zvdycky na patnactem miste Např. 963*0.1 = 96.30000000000001 = 14 mist   ALE 0.7 / 0.1 =  6.999999999999999 = 15 mist!
				return parseFloat(vysl.toFixed(pocetMist));
			}
			
			// jinak vratim to, co vzniklo nasobenim
			return vysl;
			
		}
		
		
		// presne nasobeni
		// binargon.math.multiply
		function multiply(/* libovolny pocet argumentu */){
			return mathOperation('*', Array.prototype.slice.call(arguments, 0));
		}
		
		// presne deleni (s presnosti na 14 desetinnych mist)
		function div(/* libovolny pocet argumentu */){
			return mathOperation('/', Array.prototype.slice.call(arguments, 0));
		}
		
		function plus(/* libovolny pocet argumentu */){
			return mathOperation('+', Array.prototype.slice.call(arguments, 0));
		}
		
		function minus(/* libovolny pocet argumentu */){
			return mathOperation('-', Array.prototype.slice.call(arguments, 0));
		}		
	
		// M
		this.math = {
			"div":				div,
			"minus":			minus,
			"multiply":		multiply,
			"plus":				plus
		};

		// VRACI VALUE ZADANEHO OBJEKTU
		// obj						objekt, ze ktereho chci value ziskat
		//		pole  	- vrati prvni prvek
		//		string	- vrati string
		//		number	-	vrati number osetreny pomoci myParseFloat
		//		boolean	-	vrati true/false
		//		domNode	- u formularovych prvku vraci value, jinak inner html
		//		function 	- vrati to, co vraci funkce
		//
		// defaultValue 	se pouzije, pokud nejde ze zadaneho objektu value dostat (napr. pokud misto objektu prijde null, undefined...)
		function value(obj, defaultValue){
			switch(myTypeOf(defaultValue)){
				case 'array':			defaultValue = (defaultValue.length > 0) ? defaultValue[0] : '';
				case 'string': 		break;
				case 'number': 		myParseFloat(obj); break;
				case 'boolean': 	break;
				case 'domNode': 	defaultValue = defaultValue.innerHTML; break;
				case 'function': 	defaultValue = defaultValue(obj); break;
				default: 					defaultValue = ''; break;
			}

			switch(myTypeOf(obj)){
				case 'array':			return (obj.length > 0) ? obj[0] : '';
				case 'string': 		return obj; break;
				case 'number': 		return obj; break;
				case 'boolean': 	return obj;	break;
        case 'object':    return obj; break;
				case 'domNode':
					switch(obj.nodeName.toLowerCase()){
						case 'select': 	return obj.value; break;
						case 'input':
							switch(obj.type.toString().toLowerCase){
								case 'checkbox':  return parseBoolean(obj); break;
							}
							return obj.value;
						break;
					}
					return obj.innerHtml;
				break;
				case 'event':
					if('target' in obj){return value(obj.target);}
				break;
				case 'function':	return obj(); break;
			}
			return defaultValue;
		}

		this.value = value;

		/* zavolam readyStateChange, protoze dokument uz od pocatku v nejakem stavu je a i tento stav je treba zpracovat */
		zpracujAktualniStavDokumentu()

	}

})();


/* kvuli zpetne kompatibilite... nektere starsi skiny vyuzaivaji tuto funkci misto volani metody binargon.parseFloat */
function myParseFloat(str){
	return binargon.parseFloat(str);
}


        /* callback pro reCaptchu v3 */
        var binargonReCaptchaCallback = function(){
          grecaptcha.execute('6Ld3JvcUAAAAANeYatLjP_T9mzH1KePIPJkhNZFE').then(function(token) {
						//var recaptchaResponse = document.querySelectorAll('#recaptchaResponse');
            var recaptchaResponse = document.querySelectorAll('input[id="recaptchaResponse"]');
						for(var i=0; i<recaptchaResponse.length; i++){
            	recaptchaResponse[i].value = token;
						}
						/*
            var recaptchaResponse = document.getElementById('recaptchaResponse');
						if(recaptchaResponse != null){
							recaptchaResponse.value = token;
						}*/
          });
        }
      
if (!("console" in window))
{     
  window.console = {
      log: function () {},
      dir: function () {},
      clear: function () {}
  };
}
function buyButtonChange(instance, form) {
    const buyButton = form.querySelector('button[type="submit"]');
    const buttonClass = buyButton.classList[0];

	const data = instance.getData();
	const produktId = data.id;
	const instanceSelector = "produkt_" + produktId;
	const DOMelementSDaty = document.querySelector('[data-instance="' + instanceSelector + '"]');

	// nactu z HTML json s udaji o urcitem produktu
	if (DOMelementSDaty != null) {
		try {
			skindata = DOMelementSDaty.dataset.setbindext;
			skindataObj = JSON.parse(skindata);
		} catch (err) {}
	} else {
		return false;
	}

	const variant = data.svazanyParametr.selectedKombinace;
	const stock = variant ? variant.skladProEshop : data.skladProEshop;
	const supplierStock = variant ? variant.skladdodavatele : data.skladdodavatele;
	const availabilityColor = variant ? variant.deliveryColor : skindataObj.availabilityColor;
	const externalStock = skindataObj.externalStock;
	const availabilityDate = skindataObj.availabilityDate;
	const quantity = data.pocetKs;
	const pendingQuantity = skindataObj.pendingQuantity;
	const pendingQuantityDate = skindataObj.pendingQuantityDate;
	const pendingQuantityUnit = skindataObj.pendingQuantityUnit;

	if (stock >= quantity) {
		// SKLADEM Pokud je produkt skladem, vypíše se zeleně "Skladem"
		buyButton.classList.add(`${buttonClass}--onstock`);
	} else if (pendingQuantity >= quantity && pendingQuantityDate != "") {
		// OCEKAVAME 5 KS 25.6.2023 (pokud je produkt objednan u dodavatele a zaroven zname datum doruceni)
		buyButton.classList.add(`${buttonClass}--ontheway`);

	} else if (supplierStock >= quantity) {
		// SKLADEM U DODAVATELE
		buyButton.classList.add(`${buttonClass}--supplier`);
	} else if (externalStock >= quantity && availabilityDate != "") {
		// PREDOBJEDNAVKA  Pokud je v detailu produktu vyplnen pocet objednanych kusu a datum predpokladaneho doruceni
		buyButton.classList.add(`${buttonClass}--preorder`);
	} else {
		// DEFAULT = nedostupne
		buyButton.classList.add(`${buttonClass}--availability`);
	}
}// #466982158#
// #139485133#
// #853686208#

function cAvailabilityGenerator(instance) {

    let result = '';
		let skindata = null;
		let skindataObj = null;

		const data = instance.getData();
		const produktId = data.id;
		const instanceSelector = 'produkt_' + produktId;
		const DOMelementSDaty = document.querySelector('[data-instance="'+instanceSelector+'"]');


		// nactu z HTML json s udaji o urcitem produktu
		if(DOMelementSDaty != null){
			try{
				skindata = DOMelementSDaty.dataset.setbindext;
        		skindataObj = JSON.parse(skindata);
			}catch(err){
			}
		}


		// pokud byly nalezeny data k produktu
		if(skindata != null && skindataObj != null){

	    const variant = data.svazanyParametr.selectedKombinace;
	    const stock = variant ? variant.skladProEshop : data.skladProEshop;
	    const supplierStock = variant ? variant.skladdodavatele : data.skladdodavatele;
	    const availabilityColor = variant ? variant.deliveryColor : skindataObj.availabilityColor;
	    const externalStock = skindataObj.externalStock;
		const availabilityDate = skindataObj.availabilityDate;
	    const quantity = data.pocetKs;
	    const pendingQuantity = skindataObj.pendingQuantity;
	    const pendingQuantityDate = skindataObj.pendingQuantityDate;
      	const pendingQuantityUnit = skindataObj.pendingQuantityUnit;



		  if (stock >= quantity) {
				// SKLADEM Pokud je produkt skladem, vypíše se zeleně "Skladem"
				result = `<div class="cAvailabilityRow cAvailabilityRow--onstock">${scootshopMAXI.lang.onstock}</div>`;

			} else if (pendingQuantity >= quantity && pendingQuantityDate != "") {
				// OCEKAVAME 5 KS 25.6.2023 (pokud je produkt objednan u dodavatele a zaroven zname datum doruceni)
				result = `<div class="cAvailabilityRow cAvailabilityRow--ontheway">${scootshopMAXI.lang.weexpect} ${pendingQuantity} ${pendingQuantityUnit} ${pendingQuantityDate}</div>`;

			} else if (supplierStock >= quantity) {
				// SKLADEM U DODAVATELE
				result = `<div class="cAvailabilityRow cAvailabilityRow--supplier">${scootshopMAXI.lang.supplier}</div>`;

			} else if (externalStock >= quantity && availabilityDate != "") {
				// PREDOBJEDNAVKA  Pokud je v detailu produktu vyplnen pocet objednanych kusu a datum predpokladaneho doruceni
				result = `<div class="cAvailabilityRow cAvailabilityRow--preorder">${scootshopMAXI.lang.preorder} ${scootshopMAXI.lang.date} ${availabilityDate}</div>`;

			} else {
        // DEFAULT = nedostupne
				let style = availabilityColor ? `style="--cAvailability-color:${availabilityColor}"` : "";
				result = `<div class="cAvailabilityRow cAvailabilityRow--availability" ${style}>${scootshopMAXI.lang.notavailable}</div>`;

			}

		}

		
    return result;

};
var binargon_onCommplete = binargon_onCommplete || [];
binargon_onCommplete.push(function(){

	var cCmsTree = window.cCmsTree = new cCmsTreeClass({
		"selector": 					".cCmsTree",
		"toggleSelector": 		".cCmsTree__toggle"
	});

});var cDelivery = new cDeliveryClass({
	"triggers": ".js-cDelivery",
	"modalDialog": true,
	"productIdAttribute": "data-productid",
  "productPriceAttribute": "productPriceVatAttribute"
});const menuItems = document.querySelectorAll('.menu__item');

if (menuItems.length) {
	var headerMenu = new cHeaderMenuClass({
		menuSelector: ".menu__link--submenu",
		activeMenuClass: "menu__link--active",

		submenuSelector: ".cSubmenu",
		activeSubmenuClass: "cSubmenu--active",

		menuCategoryIdAttribute: "data-id",
		submenuCategoryIdAttribute: "data-id",

		overflow: {
			container: ".menu__content",
			overflowItem: ".menu__item",

			hiddenOverflowItem: "menu__item--hidden",
			coveredOverflowItem: "menu__item--covered",

			menuSelector: ".menu__dropdown",
			activeMenuClass: "menu__dropdown--active",

			submenuSelector: ".menu__submenu-overflow",
			activeSubmenuClass: "menu__submenu-overflow--active",
		},
	});
}
	var whisperer = new cWhispererClass({
	selector: ".js-cWhisperer",
	selectorClosest: ".search",
	offsetTop: 0,

	imageproduct_width: 90,
	imageproduct_height: 90,

	products: 5,
	categories: 3,
	vyrobci: 3,
	blog: 3,
	cmsPage: 3,

	cacheTime: 180,

	breakpoints: {
		"0-800": {
			fullscreen: true,
		},
	},
});var binargon_onCommplete = binargon_onCommplete || [];
 binargon_onCommplete.push(function(){

   var commonBurgerMenu = new commonBurgerMenuClass({
		zobrazitMenuUzivatele: 1,
		zobrazitMenuJazykuAMen: 1,
		zobrazitMeny: binargonConfigMaxi.enableCurrency,
		categoryImageWidth: 0,
		categoryImageHeight: 0,
		zobrazitObchodniPodminky: 1,
		zobrazitReklamace: 0,
		zobrazitKontakty: 1,
		limitCategoryImageByLevel: [],
		zobrazitTextoveStrankyArea: ["burger"],
		kategorieLevel: 1,
		kategorieLevel: binargonConfigMaxi.treeOpenLevelLimit,
   });
 }); var binargon_onCommplete = binargon_onCommplete || [];
binargon_onCommplete.push(function(){

	var commonTree = window.commonTree = new commonTreeClass({
		"selector": 					".commonTree",
		"toggleSelector": 		".commonTree__toggle"
	});

});/*
	NEMAZAT
	tento soubor slouzi ke zruseni all-quantity v MAXi
*/function scrollToElement(elementId) {
    const element = document.getElementById(elementId);

    if (element)
        element.scrollIntoView({ behavior: "smooth" });
}

//
// SETBIND ve vsech vypisech vsech produktu (v katalogu, v souvisejicich atd...) KROME DETAILU
//



// EVENT - hlida, zda nedoslo ke smazaninejakeho produktu na strance
addEventListener('binargon-ajaxkatalog-nahrazeniProduktu', function(ev){
	if('dosloKeSmazaniProduktu' in window){
		window.dosloKeSmazaniProduktu(ev.detail.nahrazenyContainer);
	}
	ev = null;
});


// EVENT hlida, zda nedoslo k pridani produktu na strance
addEventListener('binargon-ajaxkatalog-zmena', function(ev){
	if('zalozDetailyProduktu' in window){
		window.zalozDetailyProduktu();
	}
	ev = null;
});


// ZMENA VOLITELNEHO PARAMETRU U PRODUKTU
// zkontroluje, zda se jiz provedl script pro zalozeni setbindu na strance a pokud ano, preda mu, jaka vlastnost se ma zmenit
function zmenVlastnostVKatalogu(selectbox){
	var product = selectbox.closest('.product');
	if(product != null && 'zmenVlastnostVKatalogu_interni' in window){
		window.zmenVlastnostVKatalogu_interni(product, selectbox)
	}
}


function zmenSvazaneVKatalogu(selectbox){
  var product = selectbox.closest('.product');
	if(product != null && 'zmenSvazaneVKatalogu_interni' in window){
		window.zmenSvazaneVKatalogu_interni(product, selectbox)
	}
}


// PO NACTENI STRANKY
var binargon_onCommplete = binargon_onCommplete || [];
binargon_onCommplete.push(function () {

	// seznam jiz prochazenych produktu (index vsech jiz zalozenych setbindu)
	var jizZpracovaneProdukty = new WeakMap();


	// zmeni vlastnost
	window.zmenVlastnostVKatalogu_interni =  function(product, selectbox){
		if(jizZpracovaneProdukty.has(product)){
			jizZpracovaneProdukty.get(product).changeParametr(selectbox)
		}
	}


	// zmeni svazane
	window.zmenSvazaneVKatalogu_interni =  function(product, selectbox){
		if(jizZpracovaneProdukty.has(product)){
			jizZpracovaneProdukty.get(product).changeSvazane(selectbox)
		}
	}


	// odstraneni produktu ze stranky = smazu produktu z weakmapy (seznamu jiz zpracovanych produktu)
	window.dosloKeSmazaniProduktu = function(smazanyContainer){
		smazanyContainer.querySelectorAll('.product').forEach(produkt=>{
			if(jizZpracovaneProdukty.has(produkt)){
        jizZpracovaneProdukty.delete(produkt);
			}
		});
    smazanyContainer = null;
	}

	// zalozeni setbindu
	window.zalozDetailyProduktu = function(){
		// pro vsechny produkty na strance
		document.querySelectorAll(".product").forEach((product) => {

			var form = product.querySelector('.productPurchase');
			var dataString = null;
			var data = null;

			// zjistim, zda v produktu najdu formular a jeho data (data o produktu, jako je cena, varianty atd..)
			if(!jizZpracovaneProdukty.has(product) && form != null){

				dataString = form.getAttribute('data-setdata');
				try{
					data = JSON.parse(dataString);
				}catch(err){
				}

			}

			// pokud jsem data nenasel, tak funkce konci
			if(data == null){
				return;
			}

			// uvnitr produktu najde elementy se zadanym selectorem a vrati pole
			function find(selector){
				return product.querySelectorAll(selector);
			}

			// zalozeni detailu produktu
			var productDetail = new produktDetailClass();

			productDetail.setBind({
				name: find(".productName"),
				//kosikNode: 								find('.productPurchase'), // NEPOZIVAT, jinak se formulari nastavi display: block
				nakupProductId: find("input[name=nakup]"),
				cenaCelkemS: find(".productPrice__current .cPrice__value"),
				plus: find(".quantity__button--plus"),
				minus: find(".quantity__button--minus"),
				pocetKs: find(".quantity__input"),
				cAvailability: find(".productAvailability"),
				cAvailabilityGenerator: cAvailabilityGenerator,
				kod: find(".productCode__value"),
				//image:        						find('.product__image'), 					// NEPOUZIVAT, obrazek se roztahne
				submitButton: find(".productPurchase__button"),
				submitButtonClass: {
					inStock: ["productPurchase__button--on-stock"],
					notInStock: ["productPurchase__button--out-stock"],
					inStock_skladdodavatele: ["productPurchase__button--on-supplier"],
					notInStock_skladdodavatele: ["productPurchase__button--out-supplier"],
				},
			});

			productDetail.setData(data);

			productDetail.addEvent("podproduktChange", function () {
				buyButtonChange(productDetail, form);
			});

			productDetail.redraw();

			buyButtonChange(productDetail, form);

			// pridam do seznamu jiz zpracovanych elementu
			jizZpracovaneProdukty.set(product, productDetail)

			

		});

		function zmenaTlacitkaKoupit(json,data) {
			//console.log(json, data);
		}

	}

	// zalozim setbind pro produkty, ktere jsou na strance pri jejim nacteni
	window.zalozDetailyProduktu();

});toCart = new toCartClass({
	replaceElements: ".js-to-cart",
	basketHtml: {
		".js-cart": `<a class="control__item control__item--cart" href="#href#" rel="nofollow"><div class="control__item-icon"><img class="control__item-image" src="https://i.binargon.cz/demoeshopmaxi/${binargonConfigMaxi.colorPrimary}/cart.svg" width="26" height="26" alt="cart" loading="lazy"><div class="control__item-notification">#pocet#</div></div><div class="control__item-title control__item-title--active"><span class="control__item-title-price">#cenaS#</span>&nbsp;<span class="control__item-title-currency">#mena#</span></div></a>`,
	},
}); 
//UMELA_CHYBA_9();
var binargon_onCommplete = binargon_onCommplete || [];
binargon_onCommplete.push(function () {
	const containers = document.querySelectorAll(".js-products-glide");

	if (!containers.length) return;

	let Sliders = new Array(containers.length).fill(null);
	let ResizeDelayExecution;

	
	 // projde všechny elementy s třídou .js-products-glide na stráce a inicializuje (případně aktualizuje, pokud již existují) pro ně slidery
	
	function updateAllSliders() {
		containers.forEach((container, i) => {
			sliderUpdate(container, Sliders[i], i);
		});
	}

	//
	// * nastaví počet slidů, které mají být vždy viditelné
	// * @param {HTMLElement} container - hlavní obalující prvek
	// * @returns {Number} - počet produktů, které jsou vždy viditelné
	//
	function slidesPerView(container) {
		const containerWidth = container.clientWidth;
		const product = document.querySelector(".product");

		const desktop = product.classList.contains("product--xl-thin") ? 5 : 4;
		const notebook = product.classList.contains("product--l-thin") ? 4 : 3;
		const tablet = product.classList.contains("product--m-thin") ? 3 : 2;
		const mobile = product.classList.contains("product--s-thin") ? 2 : 1;

		let perView = mobile;

		if (containerWidth >= 1300) {
			perView = desktop;
		} else if (containerWidth >= 1024 && containerWidth < 1300) {
			perView = notebook;
		} else if (containerWidth >= 640 && containerWidth < 1024) {
			perView = tablet;
		}

		return perView;
	}

	//
	// aktualizuje nebo incializuje nastavení slideru
	// @param {HTMLElement} container - hlavní kontejner
	// @param {Object} slider - konkrétní slider
	// @param {Number} position - pozice na stránce (začíná 0)
	//
	function sliderUpdate(container, slider, position) {
		let perView = slidesPerView(container);

		if (slider == null) {
			slider = new Glide(container, { perView: perView, type: "carousel", gap: 0 }).mount();
		} else {
			slider.update({ perView: perView });
		}

		// else if (slider) {
		// 	slider.destroy();
		// 	slider = null;
		// }

		Sliders[position] = slider;
	}
    
    updateAllSliders();

	// RESIZE
	window.addEventListener("resize", (event) => {
		clearTimeout(ResizeDelayExecution);
		ResizeDelayExecution = setTimeout(updateAllSliders, 100);
	});

});
var controlsHTML = [];

controlsHTML.push('<div class="productGallery__controls" data-glide-el="controls">');
	controlsHTML.push('<button class="productGallery__arrow productGallery__arrow--prev" data-glide-dir="<"></button>');
	controlsHTML.push('<button class="productGallery__arrow productGallery__arrow--next" data-glide-dir=">"></button>');
controlsHTML.push("</div>");

addEventListener("binargon-variants-pridaniObrazkuVariant", function (ev) {
	var container = ev.detail.container.parentElement.parentElement;

	if (ev.detail.pocetVariantSObrazkem > 3) {
		container.innerHTML += controlsHTML.join('');

		new Glide(container, {
			type: "carousel",
			startAt: 0,
			perView: 3,
			gap: 16,
		}).mount();
	}
});

var binargon_onCommplete = binargon_onCommplete || [];
binargon_onCommplete.push(function () {
	var variants = (window.variants = new variantsClass({
		productSelector: ".js-product",
		productId: "data-productid",
		showImages: true,
		showParams: true,
		paramsTargetSelector: ".js-product-variants",
		showVariantsCount: false,
		zmenseniHlavnihoObrazku: false,
		imageSelector: ".js-product-image",
		imageWidth: 39,
		imageHeight: 39,
		vynechatNahledyBezObrazku: true,
		imagesTargetSelector: ".js-product-gallery",
	}));
});
var binargon_onCommplete = binargon_onCommplete || [];
binargon_onCommplete.push(function () {
    document.querySelectorAll('.js-fancy-thumbnail').forEach(item => item.setAttribute('data-fslightbox', 'gallery'));
    refreshFsLightbox();
});/*soubor nesplnil podmínky pro include fce-1-banners.js*//*soubor nesplnil podmínky pro include fce-1-countdown.js*//*soubor nesplnil podmínky pro include fce-1-producersSlider.js*/var cParamDescription = new cParamDescriptionClass({
  "triggers":".js-cParamDescription-trigger",
	"paramIdAttribute":"data-paramid"
});/*soubor nesplnil podmínky pro include fce-2-3-ajaxCatalog.js*//*soubor nesplnil podmínky pro include fce-2-3-cFilterDialog.js*//*soubor nesplnil podmínky pro include fce-2-3-sortExplanation.js*/var cShare = new cShareClass({
	"triggers":".js-cShare"
});// velikostni tabulky
new cVelikostniTabulky({
});// var binargon_onCommplete = binargon_onCommplete || [];
// binargon_onCommplete.push(function () {

// 	var lastWidth = null;

// 	const column = document.querySelector(".fce6__subgrid");
// 	const leftColumn = document.querySelector(".fce1__grid-side");
// 	const leftColumnWidth = leftColumn ? 0 : 325;

// 	const tabletMaxColumnWidth = 1005 + leftColumnWidth;
// 	const mobileMaxColumnWidth = 539;

// 	let MobileGallerySlider = null;

// 	const galleryContainer = document.getElementById("js-fce6-gallery");

// 	if (!galleryContainer)
// 		return;
	
// 	function MobileGallerySliderUpdate() {
// 		if (window.innerWidth != lastWidth) {
// 			lastWidth = window.innerWidth;

// 			let settings = getSliderSettings();

// 			if (MobileGallerySlider) {
// 				MobileGallerySlider.update(settings);
// 			}

// 			if (column.clientWidth < tabletMaxColumnWidth && MobileGallerySlider == null) {
// 				let slider = new Glide(galleryContainer, settings);

// 				slider.on("mount.after", () => {
// 					galleryContainer.classList.remove("invisible");
// 				});

// 				MobileGallerySlider = slider.mount();
// 			} else if (column.clientWidth > tabletMaxColumnWidth && MobileGallerySlider) {
// 				MobileGallerySlider.destroy();
// 				MobileGallerySlider = null;
// 				galleryContainer.classList.add("invisible");
// 			}
// 		}
		
// 	}

// 	function getSliderSettings() {
// 		let settings = { perView: 1, type: "slider", gap: 20, peek: 0, touchAngle: 25 };
// 		return settings;
// 	}

// 	// RESIZE

// 	let ResizeDelayExecution;

// 	window.addEventListener('resize', event => {
// 		clearTimeout(ResizeDelayExecution);
// 		MobileGallerySliderUpdate();
// 	});

// 	MobileGallerySliderUpdate();
// });// Hlavni obrazek produktu
var setbindMainImage=document.getElementById("setbind-image");

// Konfigurace setbindu
var setbindJSON = {
	cAvailability: "setbind-cAvailability",
	ean: "setbind-ean",
	nakupProductId: "setbind-product-id",
	errorNode: "setbind-error",
	kosikNode: "setbind-cart-node",
	name: "setbind-name",
	image: "setbind-image",
	sizex: setbindMainImage.dataset.width,
	sizey: setbindMainImage.dataset.height,
	stav: "setbind-labels",
	stavNode: "setbind-labels-node",
	cenaBez: "setbind-price-tax-excluded",
	cenaS: "setbind-price-tax-included",
	beznaCenaS: "setbind-price-before",
	beznaCenaBez: "setbind-price-excl-before",
	beznaCenaSNode: "setbind-price-before-node",
	zaVychoziJednotku_cenaBez: "setbind-unit-price-tax-excluded",
	zaVychoziJednotku_cenaS: "setbind-unit-price-tax-included",
	pocetKs: "setbind-quantity",
	usetritePercent_node: ["setbind-savings-percent-node-1", "setbind-savings-percent-node-2", "setbind-savings-percent-node-3"],
	usetritePercent: ["setbind-savings-percent-1", "setbind-savings-percent-2", "setbind-savings-percent-3"],
	mnozstevniSlevy: "setbind-discounts-table",
	mnozstevniSlevyNode: "setbind-discounts-node",
	kod: ["setbind-code", "setbind-code-2"],
	//dostupnost: "setbind-availability",
	plus: "setbind-plus",
	minus: "setbind-minus",
	cartUnit: "setbind-cart-unit",
	cartUnitName: ["setbind-cart-unit-name", "setbind-cart-unit-name-2"],
	cartUnitTable: "setbind-cart-unit-table",
	cartUnitTable_node: "setbind-cart-unit-node",
	cenaCelkemBez: "setbind-price-total-tax-excluded",
	cenaCelkemS: "setbind-price-total-tax-included",
	pridavneProdukty: "setbind-additional-products",
	submitButton: "setbind-submit",
	errorNodeGenerator: function(errors){
		const errorElement = document.getElementById('setbind-error');
		let HTML = '';

		if (!errors.length) return false;

		if(errorElement.dataset.custom?.length){
			HTML += errorElement.dataset.custom;
		} else {
			HTML += '<ul class="produktDetailErrorList">';
				errors.forEach(error => { HTML += error;});
			HTML += '</ul>';
		}

		return HTML;
	},
	/*
	submitButtonClass: function (data) {
		console.log(data);
	}*/
	submitButtonClass: {
		inStock: ["fce6PurchaseControl__button--on-stock"],
		notInStock: ["fce6PurchaseControl__button--out-stock"],
		inStock_skladdodavatele: ["fce6PurchaseControl__button--on-supplier"],
		notInStock_skladdodavatele: ["fce6PurchaseControl__button--out-supplier"],
	},

};// #466982158#
// #139485133#
setbindJSON.cAvailabilityGenerator = cAvailabilityGenerator;/* DOM LOADED */
var binargon_onCommplete = binargon_onCommplete || [];
binargon_onCommplete.push(function(){
	var produktDetail = window.produktDetail = new produktDetailClass();
	produktDetail.setBind(setbindJSON);
  produktDetail.setData(JSON.parse(document.getElementById('setbind-detail').getAttribute('data-setData')));
  produktDetail.setKombinaceSkladADostupnost(JSON.parse(document.getElementById('setbind-detail').getAttribute('data-setKombinaceSkladADostupnost')));
  produktDetail.redraw();
});var binargon_onCommplete = binargon_onCommplete || [];
binargon_onCommplete.push(function () {
    const form = document.querySelector(".fce6Options");

    produktDetail.addEvent("podproduktChange", function () {
		buyButtonChange(produktDetail, form);
	});
    
	buyButtonChange(produktDetail, form);
});var binargon_onCommplete = binargon_onCommplete || [];
binargon_onCommplete.push(function () {

    const reservationForm = document.getElementById('js-reservation-form');

    if(!reservationForm) return;

    const DateTime = easepick.DateTime;
    const dataFromXML = JSON.parse(reservationForm.dataset.json)?.dates;

    const bookedDates = dataFromXML ? dataFromXML.map(d => {
        if (d instanceof Array) {
            const start = new DateTime(d[0], 'YYYY-MM-DD');
            const end = new DateTime(d[1], 'YYYY-MM-DD');

            return [start, end];
        }

        return new DateTime(d, 'YYYY-MM-DD');
    }) : [];

    const pickerSettings = {
        css: [
            '/skin/demoeshopmaxi/scripts/external/easepick_bundle@1.2.1.css'
        ],
        zIndex: 100,
        //date: new Date(),
        lang: 'cs-CZ',
        plugins: ['LockPlugin'],
        LockPlugin: {
            minDate: new Date(),
            minDays: 0,
            inseparable: true,
            filter(date, picked) {
                if (picked.length === 1) {
                    const incl = date.isBefore(picked[0]) ? '[)' : '(]';
                    return !picked[0].isSame(date, 'day') && date.inArray(bookedDates, incl);
                }

                return date.inArray(bookedDates, '[]'); // [] označení intervalu [ - zleva uzavřený, ] - zprava uzavřený, ( - zleva otevřený, ) - zprava otevřený
            }
        },
        setup(picker) {
            picker.on('select', (e) => {
                const { view, date, target } = e.detail;

                calculatePrice();
            });
        },
    };

    pickerSettings.element = document.getElementById('js-date-start');
    const PickerStart = new easepick.create(pickerSettings);

    pickerSettings.element = document.getElementById('js-date-end');
    const PickerEnd = new easepick.create(pickerSettings);

    document.getElementById('js-time-start').addEventListener('change', event => {
        PickerStart.setTime(event.target.value);
        calculatePrice();
    });

    document.getElementById('js-time-end').addEventListener('change', event => {
        PickerEnd.setTime(event.target.value);
        calculatePrice();
    });

    function calculatePrice(currentPrice){
        const price = currentPrice ? currentPrice : binargon.parseFloat(produktDetail.calcCena().cenaS_zaVsechnyKusy);
        const priceElement = document.getElementById("js-reservation-price");
        const daysElement = document.getElementById("js-reservation-days");
        const minutesInDay = 1440;

        let start_Date = new Date(PickerStart.getDate());
        let end_Date = new Date(PickerEnd.getDate());

        // calculating total time difference
        let timeDifference =  end_Date.getTime() - start_Date.getTime();
        let minuteMilliSeconds = 1000 * 60;
        let totalMinutesDiff = Math.floor(timeDifference / minuteMilliSeconds);
        let totalDaysDiff = Math.ceil(totalMinutesDiff / minutesInDay);
        let totalDays = 1 + totalDaysDiff;

        if(totalDays > 0){
            let totalPrice = binargon.formatPrice(price * totalDays, 2, ' ');
            priceElement.innerHTML = totalPrice;
            daysElement.innerHTML = totalDays;
            document.getElementById('setbind-quantity').value = totalDays;
        }
    }

    produktDetail.onPriceChange((data) => {
        calculatePrice(data.cenaS_zaVsechnyKusy);
    });
});var binargon_onCommplete = binargon_onCommplete || [];
binargon_onCommplete.push(function () {
	const unrolls = document.querySelectorAll(".js-unroll");

	/**
	 * Projde všecchny unrolly, zjistí jejich výšku celkovou výškua nastaví ji jako CSS proměnnou. Ta se použije při rozbaleném selectu.
	 * Projde všechny hodnoty a výšku vybrané hodnoty nastaví jako CSS proměnnou. Ta se použije u sbaleného selectu.
	 * Nastaví event listerner pro každou hodnotu.
	 */
	unrolls.forEach((unroll) => {
		const unrollOpenedHeight = getUnrollOpenedHeight(unroll);
		const unrollValues = unroll.querySelectorAll(".js-unroll-value");

		unroll.style.setProperty("--unrollOpenedHeight", `${unrollOpenedHeight}px`);
		
		unroll.addEventListener("click", (event) => {
			event.stopPropagation();
			event.preventDefault();
			event.currentTarget.classList.toggle('open');
		});

		unrollValues.forEach(unrollValue => {
			if (unrollValue.classList.contains('selected'))
				unroll.style.setProperty("--unrollClosedHeight", `${unrollValue.offsetHeight}px`);

			unrollValue.addEventListener("click", (event) => selectUnrollValue(unroll, unrollValue));
		});
	});

	/**
	 * Funkce, která zjišťuje celovou velikost rozbaleného selectu
	 * @param {*} unroll element selectu
	 * @returns celková výška rozbaleného selectu
	 */
	function getUnrollOpenedHeight(unroll) {
		const unrollValues = unroll.querySelectorAll(".js-unroll-value");
		let totalValuesHeight = 0;

		unrollValues.forEach((unrollValue) => {
			totalValuesHeight += unrollValue.offsetHeight;
		});

		return totalValuesHeight;
	}

	/**
	 * Funkce, která zajišťuje vybrání hodnoty selectu
	 * @param {*} unroll element selectu
	 * @param {*} unrollValue hodnota selectu, která se má vybrat
	 */
	function selectUnrollValue(unroll, unrollValue) {
		const unrollValues = unroll.querySelectorAll(".js-unroll-value");

		unrollValues.forEach(currentValue => {
			let unrollRadio = currentValue.querySelector('input');
			let change = new Event("change");

			if (currentValue == unrollValue) {
				currentValue.classList.add("selected");
				unrollRadio.checked = true;
				unrollRadio.dispatchEvent(change);
				unroll.style.setProperty("--unrollClosedHeight", `${currentValue.offsetHeight}px`);

			} else {
				currentValue.classList.remove("selected");
				unrollRadio.checked = false;
			}
		});
	}
});/*soubor nesplnil podmínky pro include fce-9-preventMultipleSubmits.js*//*soubor nesplnil podmínky pro include fce-9.php*/

		binargon_onCommplete.push(function(){

			var fbRoot = document.getElementById('fb-root');
			var body   = document.getElementsByTagName('body')[0];

			if(fbRoot==null && body!=null){
				fbRoot = document.createElement('div');
	      fbRoot.id = 'fb-root';
				body.appendChild(fbRoot);
			}

		  window.fbAsyncInit = function(){
		    FB.init({
		      appId:'397456338840081',
		      xfbml      : true,
		      cookie     : true,
		      version    : 'v2.3'
		    });

		  };

		  (function(d, s, id){
		     var js, fjs = d.getElementsByTagName(s)[0];
		     if (d.getElementById(id)) {return;}
		     js = d.createElement(s); js.id = id;
	       js.src = "//connect.facebook.net/cs_CZ/all.js";
		     fjs.parentNode.insertBefore(js, fjs);
		  }(document, 'script', 'facebook-jssdk'));


		});

	function fb_login(){
				window.open('https://www.scootshop.cz/libs/facebook_login.php', '_blank', 'height=500,width=850');
		}
      /* recaptcha v3 */
      binargon_onCommplete.push(function(){
        var s = document.createElement('script');
          s.setAttribute('src', 'https://www.google.com/recaptcha/api.js?render=6Ld3JvcUAAAAANeYatLjP_T9mzH1KePIPJkhNZFE&onload=binargonReCaptchaCallback');
          document.getElementsByTagName('head')[0].appendChild(s);
      });
    

		binargon_onCommplete.push(function(){
			var povoleni = document.getElementById('id_povoleniCookiesCommonTemplate_binargon');
			if(povoleni!=null){
				var refreshCount = parseInt(document.getElementById('id_povoleniCookiesCommonTemplate_binargon_refreshCount').innerHTML, 10);
				var mini = document.getElementById('id_povoleniCookiesCommonTemplate_binargon_povoleniCookiesMini');
				var big = document.getElementById('id_povoleniCookiesCommonTemplate_binargon_povoleniCookiesBig');

		    document.getElementById('id_povoleniCookiesCommonTemplate_binargon_euCookies1').innerHTML = 'This site uses cookies for providing services, personalization and analyzation. You agree with this policy by using this web.';
				document.getElementById('id_povoleniCookiesCommonTemplate_binargon_euCookies4').innerHTML = 'Information on cookies usage';

				/*
				if(document.cookie.indexOf('euCookiesAgree=1') > -1){
					povoleni.style.display = 'none';
				}
				*/
				if(document.cookie.indexOf('euCookiesAgree=1') == -1){
					povoleni.style.display = 'block';
				}else{
					povoleni.style.display = 'none';
				}

				document.getElementById('id_povoleniCookiesCommonTemplate_binargon_button').addEventListener('click', function() {
					var date = new Date();
					date.setFullYear(date.getFullYear() + 10);
					document.cookie = 'euCookiesAgree=1; path=/; expires=' + date.toGMTString();
					povoleni.style.display = 'none';
				}, false);

				if(refreshCount > 1){
					povoleni.addEventListener('mouseover', function(){
						mini.style.display = 'none';
						big.style.display = 'block';
					}, false);

			    povoleni.addEventListener('mouseout', function(){
						mini.style.display = 'block';
						big.style.display = 'none';
					}, false);
				}
			}



		});

	