VF = window.VF || {};

VF.texts = {
    cz: {
        pdfLangDesc: {
            en: 'PDF anglicky',
            cz: 'PDF česky',
            sk: 'PDF slovensky',
            de: 'PDF německy',
            pl: 'PDF polsky',
            ru: 'PDF rusky'
        },
        size: {
            b: 'Bytů',
            kb: 'kB',
            mb: 'MB'
        },
        search: {
            catalog: {
                button: 'Vyhledat',
                watermark: 'vyhledat v produktech...',
                heading: 'Vyhledávání <strong>%s</strong> v produktových listech',
                count: {
                    sheet: {
                        one: 'katalogový list',
                        upto4: 'katalogové listy',
                        from5: 'katalogových listů'
                    },
                    category: {
                        one: 'kategorie',
                        upto4: 'kategorie',
                        from5: 'kategorií'
                    },
                    none: 'Nenalezeny žádné katalogové listy ani kategorie.'
                }
            },
            instructions: {
                button: 'Vyhledat',
                watermark: 'vyhledat v návodech...',
                heading: 'Vyhledávání <strong>%s</strong> v návodech',
                count: {
                    sheet: {
                        one: 'návod',
                        upto4: 'návody',
                        from5: 'návodů'
                    },
                    category: {
                        one: 'kategorie',
                        upto4: 'kategorie',
                        from5: 'kategorií'
                    },
                    none: 'Nenalezeny žádné návody ani kategorie.'
                }
            }
        },
        catalog: {
            docTitle: 'Katalog produktů - Ventile & Fittings Praha',
            catalogPageHeading: 'Katalog produktů',
            overallInfo: 'celkem %sheetCount listů v %categoryCount kategoriích'
        },
        instructions: {
            docTitle: 'Návody na montáž - Ventile & Fittings Praha',
            catalogPageHeading: 'Návody na montáž',
            overallInfo: 'celkem %sheetCount návodů v %categoryCount kategoriích'
        },
        others: {
            docTitle: 'Další odkazy - Ventile & Fittings Praha'
        }
    },
    pl: {
        pdfLangDesc: {
            en: 'PDF angielsky',
            pl: 'PDF polski'
        },
        size: {
            b: 'B',
            kb: 'kB',
            mb: 'MB'
        },
        search: {
            catalog: {
                button: 'Wyszukać',
                watermark: 'wyszukać w produktów...',
                heading: 'Wyszukiwanie <strong>%s</strong> w listach produktów',
                count: {
                    sheet: {
                        one: 'lista produktów',
                        upto4: 'listy produktów',
                        from5: 'list produktów'
                    },
                    category: {
                        one: 'kategoria',
                        upto4: 'kategorie',
                        from5: 'kategorii'
                    },
                    none: 'Nie znaleziono żadnej listy produktów.'
                }
                
            },
            instructions: {
                button: 'Wyszukać',
                watermark: 'wyszukać w instrukacjach...',
                heading: 'Wyszukiwanie <strong>%s</strong> w instrukacjach',
                count: {
                    sheet: {
                        one: 'instrukcja',
                        upto4: 'instrukcje',
                        from5: 'instrukcji'
                    },
                    category: {
                        one: 'kategoria',
                        upto4: 'kategorie',
                        from5: 'kategorii'
                    },
                    none: 'Nie znaleziono żadnej instrukcji.'
                }
            }    
        },
        catalog: {
            docTitle: 'Katalog produktów - Fluid System Technologies Polska',
            catalogPageHeading: 'Katalog produktów',
            overallInfo: 'ogółem %sheetCount list w %categoryCount kategoriach'
        },
        instructions: {
            docTitle: 'Instrukcje montażu - Fluid System Technologies Polska',
            catalogPageHeading: 'Instrukcje montażu',
            overallInfo: 'ogółem %sheetCount instrukcji w %categoryCount kategoriach'
        }
        
        
    },
    ru: {
        pdfLangDesc: {
            en: 'PDF английский',
            ru: 'PDF русский'
        },
        size: {
            b: 'B',
            kb: 'kB',
            mb: 'MB'
        },
        search: {
            catalog: {
                button: 'Искать',
                watermark: 'искать v в продуктах...',
                heading: 'Поиск <strong>%s</strong> в каталоговых листах',
                count: {
                    sheet: {
                        one: 'каталоговый лист',
                        upto4: 'каталоговые листы',
                        from5: 'каталоговых листов'
                    },
                    category: {
                        one: 'категория',
                        upto4: 'категории',
                        from5: 'категории'
                    },
                    none: 'Каталоговые листы не обнаружены.'
                }
            },
            instructions: {
                button: 'Искать',
                watermark: 'искать в инструкциях...',
                heading: 'Поиск <strong>%s</strong> в инструкциях',
                count: {
                    sheet: {
                        one: 'инструкция',
                        upto4: 'инструкции',
                        from5: 'инструкции'
                    },
                    category: {
                        one: 'категория',
                        upto4: 'категории',
                        from5: 'категории'
                    },
                    none: 'Инструкции не обнаружены.'
                }
            }
        },
        catalog: {
            docTitle: 'Каталог продуктов - Ventile & Fittings Praha',
            catalogPageHeading: 'Каталог продуктов',
            overallInfo: 'Всего %sheetCount листов в %categoryCount категориях.'
        },
        instructions: {
            docTitle: 'Инструкции по монтажу - Ventile & Fittings Praha',
            catalogPageHeading: 'Инструкции по монтажу',
            overallInfo: 'Всего %sheetCount инструкций в %categoryCount категориях.'
        }
    }
};

VF.Watermark =  {
    create: function(el) {
        var onfocus = function() {
            YAHOO.util.Dom.setStyle(label, 'display', 'none');
        };
        var onblur = function() {
            if (el.value === '') {
                YAHOO.util.Dom.setStyle(label, 'display', 'block');
            }
        };
        
        el = YAHOO.util.Dom.get(el);
        VF.assert(el, 'Watermark - no element');

        var label = YAHOO.util.Selector.query('label[for='+el.id+']', document, true);
        
        VF.assert(label, 'Watermark - no label');
        
        YAHOO.util.Event.addListener(el, 'focus', onfocus);
        YAHOO.util.Event.addListener(el, 'blur', onblur);
    }
};

VF.appendCSS = function(path) {
    var headID = document.getElementsByTagName("head")[0];         
    var cssNode = document.createElement('link');
    cssNode.type = 'text/css';
    cssNode.rel = 'stylesheet';
    cssNode.href = path;
    cssNode.media = 'screen';
    headID.appendChild(cssNode);
};

VF.getCatalogData = function(type, language) {
    language = VF.longLang(language);
    
    var data;
    if (type === 'catalog') {
        data = VF.catalogData;
    } else if (type === 'instructions') {
        data = VF.instructionsData;
    } else {
        VF.assert(false, 'data for catalog not found', language);
    }
    
    
    for (var i=0; i < data.length; i++) {
        if(language in data[i]) return data[i][language];
    };
    VF.assert(false, 'data for '+ type +' not found', language);
};
VF.initCatalog = function(type, language, searchQuery) {
    try {
        
        function _search(query, doNotAnimate) {
            catalogBrowser.search(YAHOO.lang.trim(query), 
                {
                    success: function(items) {
                        //VF.log('search results: ', items);
                        searchResults.render(items, query, true);
                        searchResults.show(doNotAnimate);
                    }
                }
            );
        }
        
        function _prepareDOM(type, counts) {
            
            var texts = VF.texts[language];

            var searchBtn = YAHOO.util.Dom.get('searchBtn');
            searchBtn.value = texts.search[type].button;

            var searchField = YAHOO.util.Dom.get('searchField');
            var searchForm = YAHOO.util.Dom.get('searchForm');
            var watermark = YAHOO.util.Selector.query('.watermark', searchForm, true);
            watermark.innerHTML = texts.search[type].watermark;
            
            VF.Watermark.create(searchField);
            
            YAHOO.util.Event.addListener(searchForm, 'submit', function(e) {
                YAHOO.util.Event.preventDefault(e);
                _search(searchField.value);
            });

            var pageHeading = YAHOO.util.Selector.query('h2', document, true);
            pageHeading.innerHTML = texts[type].catalogPageHeading;

            var sheetCount = counts.sheets;
            var categoryCount = counts.categories;
            var overallInfo = YAHOO.util.Selector.query('.overallInfo', document, true);
            overallInfo.innerHTML = texts[type].overallInfo.replace('%sheetCount', sheetCount).replace('%categoryCount', categoryCount);
            
            YAHOO.util.Dom.get('searchField').focus();
        }
        
        
        // Init catalog
        var catalogBrowser = new VF.CatalogBrowser('catalog', type, VF.getCatalogData(type, language), language);
        catalogBrowser.render();
        
        // Prepare dom
        _prepareDOM(type, {
            sheets: catalogBrowser.getSheetCount(),
            categories: catalogBrowser.getCategoryCount()
        });           
    
        // Init search result panel
        var searchResults = new VF.SearchResultPanel('results', type, { click: catalogBrowser.highlight, scope: catalogBrowser }, language );
        
        // Perform search if query exists
        var searchField = YAHOO.util.Dom.get('searchField');
        if (searchQuery) {
            searchField.value = searchQuery;
            _search(searchQuery, true);
        }
        
    } catch (e) {
        VF.error(e);
    }
};



VF.getPDFLanguageDesc = function(fileLang, catalogLang) {
    lang = VF.normalizeLang(fileLang);
    var texts = VF.texts[catalogLang];
    
    VF.assert(texts.pdfLangDesc[fileLang], 'Neznámá jazyková verze.', VF.normalizeLang(fileLang));
    
    return texts.pdfLangDesc[fileLang];
};
VF.getFileSizeDesc = function(size, catalogLang) {
    var texts = VF.texts[catalogLang].size;
    var number;
    var unit;
    
    if (size / 1024 < 1) {
        number = 1;
        unit = texts['b'];
    }
    else if ((size / (1024*1024)) < 1) {
        number = Math.round(size/1024);
        unit = texts['kb'];
    }
    else {
        number = (size / (1024*1024)).toFixed(1).replace('.', ',');
        unit = texts['mb'];
    }
    
    return number + '&nbsp;' + unit;
    
};


VF.normalizeLang = function(lang) {
    switch(lang) {
        case 'czech':
        case 'cz':
            return 'cz';
            break;
        case 'russian':
        case 'ru':
            return 'ru';
            break;
        case 'polish':
        case 'pl':
            return 'pl';
            break;
        case 'english':
        case 'en':
            return 'en';
            break;
        case 'slovak':
        case 'sk':
            return 'sk';
            break;
        case 'german':
        case 'de':
            return 'de';
            break;
        default:
            VF.assert(false, 'Neznámá jazyková verze.', lang);
    }
};
VF.longLang = function(lang) {
    switch(lang) {
        case 'czech':
        case 'cz':
            return 'czech';
            break;
        case 'russian':
        case 'ru':
            return 'russian';
            break;
        case 'polish':
        case 'pl':
            return 'polish';
            break;
        case 'english':
        case 'en':
            return 'english';
            break;
        case 'slovak':
        case 'sk':
            return 'slovak';
            break;
        case 'german':
        case 'de':
            return 'german';
            break;
        
        default:
            VF.assert(false, 'Neznámá jazyková verze.', lang);
    }
};


VF.distinct = function(words) {
    var distinctWords = [];
    if (!words) return distinctWords;
    
    for (var i = words.length - 1; i >= 0; i--){
        if (distinctWords.indexOf(words[i]) === -1) {
            distinctWords.push(words[i]);
        }
    };
    return distinctWords;
};
VF.indexOfByFn = function(array, fn, scope) {
    VF.assert(fn, 'indexOfByFn - no callback function');
    VF.assert(array && array.constructor === Array, 'indexOfByFn - not an array');
    
    scope = scope || window;
    
    for (var i=0; i < array.length; i++) {
        if (fn.call(scope, array[i], i, array)) return i;
    };
    
    return -1;
};

VF.obfuscateEmails = function(root) {
    var emails = YAHOO.util.Selector.query('a[href|="mailto:"]', root);
    var email;
    
    emails.forEach(function(e) {
        email = e.innerHTML;
        
        email = email.replace("_@_", "@").replace("_._", ".");
        
        e.setAttribute('href', "mailto:" + email);
        e.innerHTML = email;
    });
};




VF.log = function() {
    if (window.console && window.console.log) {
        try {
            window.console.log.apply(window.console, arguments);
        } catch (err) {
            var msg = '';
            for (var i=0;i<arguments.length; i++) {
                msg += arguments[i];
            }
            
            try {
                window.console.log(msg);
            }
            catch (ex) {}
            
        }
    }
};
VF.error = function() {
    if (window.console && window.console.error) {
        try {
            window.console.error.apply(window.console, arguments);
        } catch (err) {
            var msg = '';
            for (var i=0;i<arguments.length; i++) {
                msg += arguments[i];
            }
            
            try {
                window.console.error(msg);
            }
            catch (ex) {}
            
        }
    }
};
VF.assert = function() {
    if (window.console && window.console.assert) {
        try {
            window.console.assert.apply(window.console, arguments);
            // window.console.trace();
        } catch (err) {
            var msg = '';
            for (var i=0;i<arguments.length; i++) {
                msg += arguments[i];
            }
            
            try {
                window.console.assert(msg);
            }
            catch (ex) {}
            
        }
    }
};

if (!Array.prototype.map) {
    Array.prototype.map = function(fun /*, thisp*/) {
        var len = this.length;
        
        if (typeof fun != "function") {
            throw new TypeError();
        }
        
        var res = new Array(len);
        var thisp = arguments[1];
        for (var i = 0; i < len; i++) {
            if (i in this) {
                res[i] = fun.call(thisp, this[i], i, this);
            }
        }
        return res;
    };
}
if (!Array.prototype.filter) {
    Array.prototype.filter = function(fun /*, thisp*/) {
        var len = this.length;
        
        if (typeof fun != "function") {
            throw new TypeError();
        }
        
        var res = new Array();
        var thisp = arguments[1];
        
        for (var i = 0; i < len; i++) {
            if (i in this) {
                var val = this[i]; // in case fun mutates this
                
                if (fun.call(thisp, val, i, this)) {
                    res.push(val);
                }
            }
        }
        
        return res;
    };
}
if (!Array.prototype.reduce)
{
  Array.prototype.reduce = function(fun /*, initial*/)
  {
    var len = this.length >>> 0;
    if (typeof fun != "function")
      throw new TypeError();

    // no value to return if no initial value and an empty array
    if (len == 0 && arguments.length == 1)
      throw new TypeError();

    var i = 0;
    if (arguments.length >= 2)
    {
      var rv = arguments[1];
    }
    else
    {
      do
      {
        if (i in this)
        {
          rv = this[i++];
          break;
        }

        // if array contains no values, no initial value to return
        if (++i >= len)
          throw new TypeError();
      }
      while (true);
    }

    for (; i < len; i++)
    {
      if (i in this)
        rv = fun.call(null, rv, this[i], i, this);
    }

    return rv;
  };
}
if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function(elt /*, from*/) {
      var len = this.length;

      var from = Number(arguments[1]) || 0;
      from = (from < 0)
           ? Math.ceil(from)
           : Math.floor(from);
      if (from < 0)
        from += len;

      for (; from < len; from++) {
        if (from in this && this[from] === elt)
          return from;
      }
      return -1;
    };
}
if (!Array.prototype.forEach) {
    Array.prototype.forEach = function(fun /*, thisp*/) {
        var len = this.length;
        
        if (typeof fun != "function") {
            throw new TypeError();
        }
        
        var thisp = arguments[1];
        for (var i = 0; i < len; i++) {
            if (i in this) {
                fun.call(thisp, this[i], i, this);
            }
        }
    };
}


/**
*
*  URL encode / decode
*  http://www.webtoolkit.info/
*
**/
webtoolkit = {};
webtoolkit.Url = {
 
	// public method for url encoding
	encode : function (string) {
		return escape(this._utf8_encode(string));
	},
 
	// public method for url decoding
	decode : function (string) {
	    string = string.replace(/\+/g, '%20');
		return this._utf8_decode(unescape(string));
	},
 
	// private method for UTF-8 encoding
	_utf8_encode : function (string) {
		string = string.replace(/\r\n/g,"\n");
		var utftext = "";
 
		for (var n = 0; n < string.length; n++) {
 
			var c = string.charCodeAt(n);
 
			if (c < 128) {
				utftext += String.fromCharCode(c);
			}
			else if((c > 127) && (c < 2048)) {
				utftext += String.fromCharCode((c >> 6) | 192);
				utftext += String.fromCharCode((c & 63) | 128);
			}
			else {
				utftext += String.fromCharCode((c >> 12) | 224);
				utftext += String.fromCharCode(((c >> 6) & 63) | 128);
				utftext += String.fromCharCode((c & 63) | 128);
			}
 
		}
 
		return utftext;
	},
 
	// private method for UTF-8 decoding
	_utf8_decode : function (utftext) {
		var string = "";
		var i = 0;
		var c = c1 = c2 = 0;
 
		while ( i < utftext.length ) {
 
			c = utftext.charCodeAt(i);
 
			if (c < 128) {
				string += String.fromCharCode(c);
				i++;
			}
			else if((c > 191) && (c < 224)) {
				c2 = utftext.charCodeAt(i+1);
				string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
				i += 2;
			}
			else {
				c2 = utftext.charCodeAt(i+1);
				c3 = utftext.charCodeAt(i+2);
				string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
				i += 3;
			}
 
		}
 
		return string;
	}
 
};