function toggleElementInTableRow(element, elementNameToToggle) {
    var tr = element;
    while (tr.tagName.toLowerCase() != 'tr') {
        tr = tr.parentNode;
    }
    if (tr) {
        var elementToToggle = tr.querySelector('input[name="' + elementNameToToggle + '"]');
        if (!elementToToggle) {
            elementToToggle = tr.querySelector('select[name="' + elementNameToToggle + '"]');
        }
        if (elementToToggle) {
            elementToToggle.classList.toggle('hidden');
        }
    }
}
function showElement(id, element = null) {
    document.getElementById(id).classList.remove('hidden');
    if (element !== null) {
        element.parentNode.removeChild(element);
    }
}
function hideElement(id) {
    document.getElementById(id).classList.add('hidden');
}
function hideElementByInstance(el) {
    el.classList.add('hidden');
}
function showElementByInstance(el) {
    el.classList.remove('hidden');
}
function toggleElement(id) {
    document.getElementById(id).classList.toggle('hidden');
}
function disableInput(element_id, disable = true) {
    let element = document.getElementById(element_id);
    if (element && element.tagName === 'INPUT') {
        element.disabled = disable;
        if (disable) {
            element.classList.add('unvisible');
        } else {
            element.classList.remove('unvisible');
        }
    }
}
 class Page {
    constructor() {
        this.t_page_url = PAGE_URL;
        this.t_app_page_id = null;
        this.t_local_abs_url = LOCAL_ABS_URL;
        this.t_is_vat_payer = IS_VAT_PAYER;
        this.t_action_methods = {};
        window.addEventListener("load", this.init.bind(this));
        window.addEventListener("DOMContentLoaded", this.initDom.bind(this));
    }
    init() {
        console.log(Date.now());
    }
    initDom() {
        console.log(Date.now());
    }
    processActionMethods() {
        let obj = Reflect.getPrototypeOf(this);
        let keys = Reflect.ownKeys(obj);
        let i_max = keys.length;
        let i = 0;
        while (i < i_max) {
            let key = keys[i];
            if (typeof key != "string") {
                continue;
            }
            if (key.includes('Action')) {
                this.t_action_methods[key] = true;
            }
            i++;
        }
    }
    executeAction(method_name) {
        if (this.t_action_methods.hasOwnProperty(method_name)) {
            eval(`PAGE.${method_name}(${this.t_action_methods[method_name]})`);
        }
    }
    getPageUrl() {
        return this.t_page_url;
    }
    getPageUrlWithoutParams(remove_params) {
        let url = this.getPageUrl();
        let regex = new RegExp('\/(' + remove_params.join('|') + ')\/[^\/]*', 'gi');
        url = url.replace(regex, '');
        return url;
    }
    getLocalAbsUrl() {
        return this.t_local_abs_url;
    }
    getIsVatPayer() {
        return this.t_is_vat_payer;
    }
    refresh() {
        location.reload();
    }
    redirectByDataHref(element) {
        let href = element.dataset.href;
        if (href) {
            location.href = href;
        }
    }
    getAppPageId() {
        return this.t_app_page_id;
    }
    setAppPageId(app_page_id) {
        this.t_app_page_id = app_page_id;
    }
}
 class MessengerHelper {
    static underscoreToCamelCase(underscore_string, capitalize_first_letter = false) {
        let result = '';
        let chars = [...underscore_string];
        let chars_length = chars.length;
        let capitalize_next = capitalize_first_letter;
        for (let i = 0; i < chars_length; i++) {
            if (chars[i] === '_') {
                capitalize_next = true;
                continue;
            }
            if (capitalize_next) {
                chars[i] = chars[i].toUpperCase();
                capitalize_next = false;
            }
            result += chars[i];
        }
        return result;
    }
    static serializeMany(data) {
        let keys = Object.keys(data);
        let keys_length = keys.length;
        let result = {};
        let found_any = false;
        for (let i = 0; i < keys_length; i++) {
            result[keys[i]] = data[keys[i]].serialize();
            found_any = true;
        }
        if (found_any) {
            return result;
        }
        return null;
    }
    static deserializeMany(data) {
        let data_parsed = JSON.parse(data);
        let keys = Object.keys(data_parsed);
        let keys_length = keys.length;
        if (keys_length === 0) {
            return null;
        }
        let result = {};
        let found_any = false;
        for (let i = 0; i < keys_length; i++) {
            let inner_keys = Object.keys(data_parsed[keys[i]]);
            let inner_keys_length = inner_keys.length;
            if (inner_keys_length !== 1) {
                continue;
            }
            let inner_messenger_name = inner_keys[0];
            if (!inner_messenger_name.includes('Messenger')) {
                continue;
            }
            let inner_messenger = eval(`new ${inner_messenger_name}()`);
            if (inner_messenger.deserialize(data_parsed[keys[i]])) {
                found_any = true;
                result[keys[i]] = inner_messenger;
            }
        }
        if (found_any) {
            return result;
        }
        return null;
    }
}

class Messenger {
    setId(id) {
        this.t_id = id;
    }
    getId() {
        return this.t_id;
    }
    setCreatedAt(created_at) {
        this.t_created_at = created_at;
    }
    getCreatedAt() {
        return this.t_created_at;
    }
    setUpdatedAt(updated_at) {
        this.t_updated_at = updated_at;
    }
    getUpdatedAt() {
        return this.t_updated_at;
    }
    setCreatedById(created_by_id) {
        this.t_created_by_id = created_by_id;
    }
    getCreatedById() {
        return this.t_created_by_id;
    }
    setGroupId(group_id) {
        this.t_group_id = group_id;
    }
    getGroupId() {
        return this.t_group_id;
    }
    setDeleted(deleted) {
        this.t_deleted = deleted;
    }
    getDeleted() {
        return this.t_deleted;
    }
    setDeletedAt(deleted_at) {
        this.t_deleted_at = deleted_at;
    }
    getDeletedAt() {
        return this.t_deleted_at;
    }
    serialize(include_r_prefix = true) {
        let found_variables = JSON.parse(JSON.stringify(this));
        let keys = Object.keys(found_variables);
        let max_i = keys.length;
        let messenger = {};
        let variables = {};
        messenger[this.constructor.name] = variables;
        let i = 0;
        while (i < max_i) {
            let key = keys[i];
            i++;
            if (key.indexOf('t_') != 0) {
                if (!include_r_prefix) {
                    continue;
                }
                if (key.indexOf('r_') != 0) {
                    continue;
                }
            }
            let serialized_key = key.substring(2);
            let get_method_name = Messenger.GET_METHOD_PREFIX;
            get_method_name += MessengerHelper.underscoreToCamelCase(serialized_key, true);
            let get_method = this[get_method_name];
            if (typeof get_method !== 'function') {
                continue;
            }
            let variable_value = get_method.bind(this)();
            if (variable_value === null) {
            }
            else if (variable_value instanceof Messenger) {
                variable_value = variable_value.serialize();
            }
            else if (typeof variable_value === 'object') {
                let variable_value_values = Object.values(variable_value);
                let variable_value_values_length = variable_value_values.length;
                if (variable_value_values_length > 0 && variable_value_values[0] instanceof Messenger) {
                    variable_value = MessengerHelper.serializeMany(variable_value);
                }
            }
            if (typeof variable_value === 'boolean') {
                variables[serialized_key] = variable_value ? 1 : 0;
            }
            else {
                variables[serialized_key] = variable_value;
            }
        }
        return messenger;
    }
    deserialize(data) {
        let data_parsed;
        if (typeof data === 'string') {
            data_parsed = JSON.parse(data);
        }
        else {
            data_parsed = data;
        }
        if (!(this.constructor.name in data_parsed)) {
            return false;
        }
        let messenger_data = data_parsed[this.constructor.name];
        let keys = Object.keys(messenger_data);
        let keys_length = keys.length;
        for (let i = 0; i < keys_length; i++) {
            let set_method_name = Messenger.SET_METHOD_PREFIX;
            set_method_name += MessengerHelper.underscoreToCamelCase(keys[i], true);
            let set_method = this[set_method_name];
            if (typeof set_method !== 'function') {
                continue;
            }
            let variable_value = messenger_data[keys[i]];
            if (variable_value === null) {
            }
            else if (typeof variable_value === 'object') {
                let inner_keys = Object.keys(variable_value);
                let inner_keys_length = inner_keys.length;
                let is_messenger = false;
                if (inner_keys_length === 1) {
                    let inner_messenger_name = inner_keys[0];
                    if (inner_messenger_name.includes('Messenger')) {
                        is_messenger = true;
                        let inner_messenger = eval(`new ${inner_messenger_name}()`);
                        inner_messenger.deserialize(variable_value);
                        variable_value = inner_messenger;
                    }
                }
                if (!is_messenger) {
                    let variable_value_string = JSON.stringify(variable_value);
                    let messengers_array = MessengerHelper.deserializeMany(variable_value_string);
                    if (messengers_array !== null) {
                        variable_value = messengers_array;
                    }
                }
            }
            set_method.bind(this, variable_value)();
        }
        return true;
    }
}
Messenger.GET_METHOD_PREFIX = 'get';
Messenger.SET_METHOD_PREFIX = 'set';
 Messenger;
class HtmlHelper {
    static parseElement(value) {
        let element;
        if (typeof value === 'string') {
            element = document.getElementById(value);
        }
        else {
            element = value;
        }
        if (element) {
            return element;
        }
        return null;
    }
    static isOverView(element) {
        let element_bounding_rect = element.getBoundingClientRect();
        return element_bounding_rect.bottom < 0;
    }
    static processSticky(element_id, sticky_css_class = "sticky") {
        let element = document.getElementById(element_id);
        if (element === null) {
            console.log(element_id + "do not found in method processSticky()");
            return;
        }
        let element_clone = document.getElementById(element_id + "_clone");
        if (HtmlHelper.isOverView(element) === false) {
            if (element_clone !== null) {
                element_clone.remove();
            }
        }
        else {
            if (element_clone === null) {
                let clone = element.cloneNode(true);
                if (clone instanceof HTMLElement) {
                    element_clone = clone;
                    element_clone.classList.add(sticky_css_class);
                    element_clone.id = element_id + "_clone";
                    let myBody = document.getElementById("myBody");
                    myBody.appendChild(element_clone);
                }
            }
        }
    }
    static addErrorClass(value) {
        let element = HtmlHelper.parseElement(value);
        if (element !== null) {
            element.classList.add(HtmlHelper.ERROR_CLASS);
        }
    }
    static removeErrorClass(value) {
        let element = HtmlHelper.parseElement(value);
        if (element !== null) {
            element.classList.remove(HtmlHelper.ERROR_CLASS);
        }
    }
    static doShowElement(value, do_show) {
        if (do_show) {
            HtmlHelper.showElement(value);
        }
        else {
            HtmlHelper.hideElement(value);
        }
    }
    static showElement(value) {
        let element = HtmlHelper.parseElement(value);
        if (element !== null) {
            element.classList.remove(HtmlHelper.HIDDEN_CLASS);
        }
    }
    static hideElement(value) {
        let element = HtmlHelper.parseElement(value);
        if (element !== null) {
            element.classList.add(HtmlHelper.HIDDEN_CLASS);
        }
    }
    static hideAllElements(elements) {
        let length = elements.length;
        let i = 0;
        while (i < length) {
            let element = elements[i];
            if (element instanceof HTMLElement) {
                HtmlHelper.hideElement(element);
            }
            i++;
        }
    }
    static hideAllElementsByClass(elements_class_name) {
        let elements = HtmlHelper.getAllOfClass(elements_class_name);
        3;
        if (elements === null) {
            return;
        }
        HtmlHelper.hideAllElements(elements);
    }
    static toggleElement(value) {
        let element = HtmlHelper.parseElement(value);
        if (element !== null) {
            element.classList.toggle(HtmlHelper.HIDDEN_CLASS);
        }
    }
    static getElementValue(element_id) {
        let element = document.getElementById(element_id);
        if (!element) {
            return null;
        }
        if (!(element instanceof HTMLInputElement) && !(element instanceof HTMLSelectElement)) {
            return null;
        }
        return element.value;
    }
    static getTextAreaValue(element_id) {
        let element = document.getElementById(element_id);
        if (!element) {
            return null;
        }
        if (!(element instanceof HTMLTextAreaElement)) {
            return null;
        }
        return element.value;
    }
    static getFirstOfClass(class_name) {
        let collection = document.getElementsByClassName(class_name);
        if (collection.length && collection[0] instanceof HTMLElement) {
            return collection[0];
        }
        return null;
    }
    static removeClassFromAllElementsInParent(class_name, parent_element = null) {
        let elements = this.getAllOfClass(class_name, parent_element);
        if (elements === null) {
            return;
        }
        for (let i = 0; i < elements.length; i++) {
            elements[i].classList.remove(class_name);
        }
    }
    static getAllOfClass(class_name, parent_element = null) {
        let collection;
        if (parent_element == null) {
            collection = document.getElementsByClassName(class_name);
        }
        else {
            collection = parent_element.getElementsByClassName(class_name);
        }
        if (collection.length && collection[0] instanceof HTMLElement) {
            return collection;
        }
        return null;
    }
    static getElement(element_id) {
        let element = document.getElementById(element_id);
        if (element instanceof HTMLElement) {
            return element;
        }
        return null;
    }
    static getInputElement(element_id) {
        let element = HtmlHelper.getElement(element_id);
        if (element === null) {
            return null;
        }
        if (element instanceof HTMLInputElement) {
            return element;
        }
        return null;
    }
    static getFirstOfClassInParent(class_name, parent_element) {
        let collection = parent_element.getElementsByClassName(class_name);
        if (collection.length && collection[0] instanceof HTMLElement) {
            return collection[0];
        }
        return null;
    }
    static getFirstOfClassInputInParent(class_name, parent_element) {
        let element = HtmlHelper.getFirstOfClassInParent(class_name, parent_element);
        if (element instanceof HTMLInputElement) {
            return element;
        }
        return null;
    }
    static getFirstOfClassChecked(class_name) {
        let collection = document.getElementsByClassName(class_name);
        let collection_length = collection.length;
        for (let i = 0; i < collection_length; i++) {
            let element = collection[i];
            if (element instanceof HTMLInputElement && element.checked) {
                return element;
            }
        }
        return null;
    }
    static newMessageElement(message, positive) {
        let body = document.getElementById('myBodyContent');
        if (!body) {
            return null;
        }
        let message_span = document.createElement('SPAN');
        message_span.innerHTML = message;
        let message_cross = document.createElement('I');
        message_cross.classList.add('fas', 'fa-times');
        let message_section = document.createElement('SECTION');
        message_section.classList.add('pointer');
        message_section.classList.add(positive ? 'message_ok' : 'message_ko');
        message_section.addEventListener('click', HtmlHelper.hideElement.bind(null, message_section));
        message_section.appendChild(message_span);
        message_section.appendChild(message_cross);
        body.insertBefore(message_section, body.firstChild);
        return message_section;
    }
    static newErrorMessageElement(message) {
        return HtmlHelper.newMessageElement(message, false);
    }
    static newSuccessMessageElement(message) {
        return HtmlHelper.newMessageElement(message, true);
    }
    static removeAllElements(elements) {
        let length = elements.length;
        let i = 0;
        while (i < length) {
            let element = elements.item(0);
            if (element !== null) {
                element.remove();
            }
            i++;
        }
    }
    static scrollToElement(id, type) {
        let element = document.getElementById(id);
        if (!element) {
            return;
        }
        let element_bounding_rect = element.getBoundingClientRect();
        let new_scroll_top;
        if (type === "center") {
            new_scroll_top = window.scrollY + element_bounding_rect.top - window.innerHeight / 2;
        }
        else if (type === "start") {
            new_scroll_top = window.scrollY + element_bounding_rect.top;
        }
        else if (type === "end") {
            new_scroll_top = window.scrollY + element_bounding_rect.top - window.innerHeight;
        }
        else {
            return;
        }
        window.scrollTo(0, new_scroll_top);
    }
    static registerElementToBeSticky(element_id, sticky_css_class = "sticky") {
        window.addEventListener("scroll", (event) => {
            HtmlHelper.processSticky(element_id, sticky_css_class);
        });
    }
}
HtmlHelper.HIDDEN_CLASS = 'hidden';
HtmlHelper.ERROR_CLASS = 'error';
 HtmlHelper;
class UrlHelper {
    static normalizeString(string) {
        const table = {
            'š': 's', 'đ': 'dj', 'ž': 'z', 'č': 'c', 'ć': 'c',
            'à': 'a', 'á': 'a', 'â': 'a', 'ã': 'a', 'ä': 'a', 'å': 'a', 'æ': 'a', 'ç': 'c', 'è': 'e', 'é': 'e',
            'ê': 'e', 'ë': 'e', 'ì': 'i', 'í': 'i', 'î': 'i', 'ï': 'i', 'ñ': 'n', 'ò': 'o', 'ó': 'o', 'ô': 'o',
            'õ': 'o', 'ö': 'o', 'ø': 'o', 'ù': 'u', 'ú': 'u', 'û': 'u', 'ý': 'y', 'þ': 'b',
            'ÿ': 'y', 'ŕ': 'r', 'ř': 'r', 'ň': 'n', 'ě': 'e', 'ů': 'u',
        };
        return string.replace(/./g, char => table[char] || char);
    }
    static clean(string) {
        let clean_string = string.replace(/\s+/g, ' ');
        clean_string = clean_string.replace(/[^a-zA-Z0-9\u00C0-\u017F\-\/.,()@_ ]/g, '');
        clean_string = encodeURIComponent(clean_string);
        clean_string = clean_string.replace(/%2F/g, '~');
        return clean_string;
    }
    static hasUrlParam(paramName, url = window.location.href) {
        let searchParams = new URLSearchParams(url);
        return searchParams.has(paramName);
    }
    static getUrlParam(paramName, url = window.location.href) {
        let url_instance = new URL(url);
        let segments = url_instance.pathname.split("/").filter(segment => segment !== "");
        let keyIndex = segments.indexOf(paramName);
        if (keyIndex !== -1 && keyIndex + 1 < segments.length) {
            return segments[keyIndex + 1];
        }
        let searchParams = new URLSearchParams(url);
        if (searchParams.has(paramName) === false) {
            return null;
        }
        return searchParams.get(paramName);
    }
    static getUrlWithoutParam(paramName, url = window.location.href) {
        let url_instance = new URL(url);
        let searchParams = url_instance.searchParams;
        if (searchParams.has(paramName) === false) {
            return searchParams.toString();
        }
        searchParams.delete(paramName);
        return url_instance.toString();
    }
    static addUrlParam(param_name, value, url = window.location.href) {
        let url_instance = new URL(url);
        let searchParams = url_instance.searchParams;
        searchParams.append(param_name, value);
        return url_instance.toString();
    }
}
UrlHelper.HIDDEN_CLASS = 'hidden';
UrlHelper.ERROR_CLASS = 'error';
 UrlHelper;

 class DialogHelper {
    static open(dialog_html_id) {
        let element = HtmlHelper.getElement("dialog_window");
        if (element == null) {
            return;
        }
        let dialog_html_element = HtmlHelper.getElement(dialog_html_id);
        if (dialog_html_element == null) {
            return;
        }
        if (dialog_html_element.dataset.wrapperClass !== undefined) {
            let dialog_wrapper = HtmlHelper.getElement("dialog_wrapper");
            dialog_wrapper.classList.add(dialog_html_element.dataset.wrapperClass);
        }
        let template_title_element = HtmlHelper.getElement("dialog_title");
        let title_element = HtmlHelper.getFirstOfClassInParent("dialog_title", dialog_html_element);
        template_title_element.innerHTML = title_element.innerHTML;
        DialogHelper.template_title_html = title_element.innerHTML;
        title_element.innerHTML = "";
        let template_content_element = HtmlHelper.getElement("dialog_content");
        let content_element = HtmlHelper.getFirstOfClassInParent("dialog_content", dialog_html_element);
        template_content_element.innerHTML = content_element.innerHTML;
        DialogHelper.template_content_html = content_element.innerHTML;
        content_element.innerHTML = "";
        HtmlHelper.showElement(element);
    }
    static close(dialog_html_id) {
        HtmlHelper.hideElement("dialog_window");
        let dialog_html_element = HtmlHelper.getElement(dialog_html_id);
        let title_element = HtmlHelper.getFirstOfClassInParent("dialog_title", dialog_html_element);
        title_element.innerHTML = DialogHelper.template_title_html;
        let content_element = HtmlHelper.getFirstOfClassInParent("dialog_content", dialog_html_element);
        content_element.innerHTML = DialogHelper.template_content_html;
        DialogHelper.template_title_html = null;
        DialogHelper.template_content_html = null;
        let dialog_wrapper = HtmlHelper.getElement("dialog_wrapper");
        dialog_wrapper.setAttribute("class", "");
    }
}


 class CookiesHelper {
    static getCookie(cookie_name) {
        var name = cookie_name + "=";
        var decodedCookie = decodeURIComponent(document.cookie);
        var ca = decodedCookie.split(';');
        for (var i = 0; i < ca.length; i++) {
            var c = ca[i];
            while (c.charAt(0) == ' ') {
                c = c.substring(1);
            }
            if (c.indexOf(name) == 0) {
                return c.substring(name.length, c.length);
            }
        }
        return "";
    }
    static setCookie(cookie_name, cookie_value, expiration_days) {
        var d = new Date();
        d.setTime(d.getTime() + (expiration_days * 24 * 60 * 60 * 1000));
        var expires = "expires=" + d.toUTCString();
        document.cookie = cookie_name + "=" + cookie_value + ";" + expires + ";path=/";
    }
    static addCookie() {
    }
    static deleteCookie(cookie_name) {
        CookiesHelper.setCookie(cookie_name, "", -1);
    }
    static showCookiesMessage() {
        let cookie_value = CookiesHelper.getCookie('cookies_accepted');
        if (cookie_value == "1") {
            HtmlHelper.hideElement('cookies_message');
        }
        else {
            HtmlHelper.showElement('cookies_message');
        }
    }
    static acceptAllCookies() {
        HtmlHelper.hideElement('cookies_message');
        CookiesHelper.setCookie('cookies_accepted', 1, 365);
        CookiesHelper.setCookie('cookies_analytical_accepted', 1, 365);
        CookiesHelper.setCookie('cookies_marketing_accepted', 1, 365);
        DataLayerHelper.processConsent();
    }
    static switchCookie(cookie_name) {
        let cookie_value = CookiesHelper.getCookie(cookie_name);
        if (cookie_value == "1") {
            CookiesHelper.deleteCookie(cookie_name);
        }
        else {
            CookiesHelper.setCookie(cookie_name, 1, 365);
        }
        DataLayerHelper.processConsent();
    }
    static initDialogValues() {
        let cookie_value = CookiesHelper.getCookie('cookies_analytical_accepted');
        console.log(cookie_value);
        if (cookie_value == "1") {
            let element = HtmlHelper.getElement("analytical_cookies");
            element.checked = true;
        }
        cookie_value = CookiesHelper.getCookie('cookies_marketing_accepted');
        console.log(cookie_value);
        if (cookie_value == "1") {
            let element = HtmlHelper.getElement("marketing_cookies");
            element.checked = true;
        }
    }
}

 class DataLayerHelper {
    static push(...args) {
        gtag(...args);
    }
    static processConsent() {
        let cookies_accepted = CookiesHelper.getCookie("cookies_accepted");
        let consent_update_values = {};
        let do_update_consent = false;
        let analytical_accepted = CookiesHelper.getCookie("cookies_analytical_accepted");
        if (analytical_accepted !== "") {
            consent_update_values.analytics_storage = "granted";
            do_update_consent = true;
        }
        let marketing_accepted = CookiesHelper.getCookie("cookies_marketing_accepted");
        if (marketing_accepted !== "") {
            consent_update_values.ad_storage = "granted";
            consent_update_values.ad_user_data = "granted";
            consent_update_values.ad_personalization = "granted";
            consent_update_values.personalization_storage = "granted";
            do_update_consent = true;
        }
        if (do_update_consent === true) {
            DataLayerHelper.push("consent", "update", consent_update_values);
        }
    }
}
window.dataLayer = window.dataLayer || [];
function gtag() { dataLayer.push(arguments); }
gtag("js", new Date());
DataLayerHelper.push(
    'consent', 'default',
    {
        "ad_storage": "denied",
        "ad_user_data": "denied",
        "ad_personalization": "denied",
        "analytics_storage": "denied",
        "personalization_storage": "denied",
        "functionality_storage": "granted",
        "security_storage": "granted"
    }
);
DataLayerHelper.processConsent();if (GTM_CODE !== '') {
    (function (w, d, s, l, i) {
        w[l] = w[l] || []; w[l].push({
            'gtm.start':
                new Date().getTime(), event: 'gtm.js'
        }); var f = d.getElementsByTagName(s)[0],
            j = d.createElement(s), dl = l != 'dataLayer' ? '&l=' + l : ''; j.async = true; j.src =
                'https://www.googletagmanager.com/gtm.js?id=' + i + dl; f.parentNode.insertBefore(j, f);
    })(window, document, 'script', 'dataLayer', GTM_CODE);
}
function isMobile() {
    let userAgent = navigator.userAgent || navigator.vendor || window.opera;
    userAgent = userAgent.toLowerCase();

    const toMatch = [
        /android mobile/i,
        /webos/i,
        /iphone/i,
        /ipod/i,
        /blackberry/i,
        /windows phone/i,
        /mobile safari/i
    ];
    let i = toMatch.length - 1;
    while (i > -1) {
        if (toMatch[i].test(userAgent)) {

            return true;
        }
        i--;
    }

    if (navigator.maxTouchPoints && navigator.maxTouchPoints > 4) {
        if (/macintel/.test(userAgent)) {

            return true;
        }
    }


    let is_portrait_mode = window.matchMedia("(orientation: portrait)").matches;
    if (is_portrait_mode === true) {
        return true;
    }
    return false;
}
function initMobileMenu() {
    let is_mobile = isMobile();
    if (is_mobile == true) {
        let menu_buttons = document.getElementById("menu_buttons");
        let menu_mobile_button = document.getElementById("menu_mobile_button");
        let menu = document.getElementById("menu");
        menu_buttons.classList.add("menu_buttons_mobile");
        menu_mobile_button.classList.remove("hidden");
        menu.classList.remove("menu_vertical");
        menu.classList.add("menu_horizontal");
        document.body.classList.add("is_mobile");
    } else {
        document.body.classList.add('is_desktop');
    }
}
function showOrHideMenuButtons() {
    let menu_buttons = document.getElementById("menu_buttons");
    if (menu_buttons.classList.contains("active")) {
        menu_buttons.classList.remove("active");
    } else {
        menu_buttons.classList.add("active");
    }
}
function showOrHideMenuGroup(group_id, el_me) {
    let el = document.getElementById(group_id);
    let true_height = el.getAttribute("data-true-height") + "px";
    if (el_me.classList.contains("active")) {
        el.style.height = "0px";
        el_me.classList.remove("active");
    } else {
        el.style.height = true_height;
        el_me.classList.add("active");
    }
}
function menuWidthCheck(group_id, mobile_w = menuMobileWidth) {
    if (menuStartWidth === window.innerWidth) {
        return;
    }
    let el = document.getElementById(group_id);
    if (window.innerWidth >= mobile_w) {
        if (el.style.height == "0px") {
            let true_height = el.getAttribute("data-true-height") + "px";
            el.style.height = true_height;
            menuStartWidth = window.innerWidth;
        }
    } else {
        if (menuStartWidth > mobile_w) {
            el.style.height = "0px";
            menuStartWidth = 0;
        }
    }
}
function isMenuGroupOpen(group_el) {
    let elems = group_el.getElementsByClassName("a_menu_active");
    if (elems.length > 0) {
        return true;
    }
    return false;
}
function calculateMenuGroupHeight(group_id, group_button_id) {
    let el = document.getElementById(group_id);
    el.setAttribute("data-true-height", el.offsetHeight);
    let group_button_el = document.getElementById(group_button_id);
    if (!group_button_el.classList.contains("active")) {
        el.style.height = "0px";
    }
}
function isElementInViewport(el) {
    let viewPortDelta = window.innerHeight / 3;
    let view_bottom = window.screenTop + window.innerHeight;
    let rect = el.getBoundingClientRect();
    if (rect.top > viewPortDelta && rect.top < view_bottom) {
        return true;
    }
    if (rect.bottom > viewPortDelta && rect.bottom < view_bottom) {
        return true;
    }
    if (rect.top < viewPortDelta && rect.bottom > view_bottom) {
        return true;
    }
    return false;
}
function setVisibilityOfInternalLinks(buttons) {
    let buttons_length = buttons.length;
    let button_active = null;
    for (let i = 0; i < buttons_length; i++) {
        let button = buttons[i];
        let target_id = button.dataset.targetId;
        let element = document.getElementById(target_id);
        if (isElementInViewport(element)) {
            button_active = button;
            break;
        }
    }
    if (button_active !== null) {
        for (let i = 0; i < buttons_length; i++) {
            if (buttons[i] === button_active) {
                buttons[i].classList.add('active');
            } else {
                buttons[i].classList.remove('active');
            }
        }
    }
}
window.addEventListener('load', function () {
    let buttons = document.getElementsByClassName('internal_link_button');
    setVisibilityOfInternalLinks(buttons);
    window.addEventListener('scroll', function () {
        setVisibilityOfInternalLinks(buttons);
    });
});

function videoPlayOrPause(video_el_id, video_placeholder_el_id) {
   let el_video = document.getElementById(video_el_id);
   let el_video_placeholder = document.getElementById(video_placeholder_el_id);
   let running = el_video.getAttribute("data-running");

   if(running == 0) {
      videoSwitchHidden(el_video_placeholder, el_video, el_video, 1);
      el_video.play();
      window.setTimeout(function() {elementSetHidden(el_video_placeholder)}, 500);
   }else{
      videoSwitchHidden(el_video, el_video_placeholder, el_video, 0);
      el_video.pause();
      window.setTimeout(function() {elementSetHidden(el_video)}, 500);
   }
}
function videoSwitchHidden(el_to_hide, el_to_show, el_video, running) {
   el_video.setAttribute("data-running", running);
   el_to_show.classList.remove("hiding");
   el_to_show.classList.remove("unvisible");
   el_to_hide.classList.add("hiding");
}
function elementSetHidden(el) {
   el.classList.add("unvisible");
}

class Slider {
    constructor(html_id, interval, prev_slides = 0, next_slides = 0) {
        this.slider_wrapper = document.getElementById(html_id);
        this.slides = [];
        this.slides_length = 0;
        this.active_slide = 0;
        let slider = this.slider_wrapper.getElementsByClassName('slider');
        if (slider && slider[0]) {
            this.slides = slider[0].getElementsByClassName('slide');
            this.slides_length = this.slides.length;

            slider[0].addEventListener('touchstart', this.stopInterval.bind(this));
            slider[0].addEventListener('touchend', this.startInterval.bind(this));
        }
        this.navigations = [];
        this.navigations_length = 0;
        let navigation = this.slider_wrapper.getElementsByClassName('slider_navigation');
        if (navigation && navigation[0]) {
            this.navigations = navigation[0].childNodes;
            this.navigations_length = this.navigations.length;
        }
        this.prev_slides = prev_slides;
        this.next_slides = next_slides;
        this.interval = interval;
        this.interval_id = null;
        this.resetInterval();
        if (this.slides_length > 0) {
            this.setSlidesClasses();
            this.setNavigationClasses();
        }
    }
    stopInterval() {
        if (this.interval_id !== null) {
            clearInterval(this.interval_id);
            this.interval_id = null;
        }
    }
    startInterval() {
        if (this.interval > 0) {
            this.interval_id = setInterval(this.moveNext.bind(this), this.interval);
        }
    }
    resetInterval() {
        this.stopInterval();
        this.startInterval();
    }
    setSlidesClasses() {

        let slide_indexes = [];
        for (let i = 0; i < this.slides_length; i++) {
            slide_indexes[i] = true;
            this.slides[i].classList.remove('slide_active');
            for (let p = 1; p <= this.prev_slides; p++) {
                this.slides[i].classList.remove('slide_prev_' + p);
            }
            for (let n = 1; n <= this.next_slides; n++) {
                this.slides[i].classList.remove('slide_next_' + n);
            }
        }

        this.slides[this.active_slide].classList.add('slide_active');
        slide_indexes[this.active_slide] = false;

        let n_index = this.active_slide + 1;
        for (let n = 1; n <= this.next_slides; n++) {
            if (n_index >= this.slides_length) {
                n_index = 0;
            }
            if (slide_indexes[n_index] === false) {
                break;
            }
            this.slides[n_index].classList.add('slide_next_' + n);
            slide_indexes[n_index] = false;
            n_index--;
        }

        let p_index = this.active_slide - 1;
        for (let p = 1; p <= this.prev_slides; p++) {
            if (p_index < 0) {
                p_index = this.slides_length - 1;
            }
            if (slide_indexes[p_index] === false) {
                break;
            }
            this.slides[p_index].classList.add('slide_prev_' + p);
            slide_indexes[p_index] = false;
            p_index--;
        }
    }
    setNavigationClasses() {
        for (let i = 0; i < this.navigations_length; i++) {
            if (!this.navigations[i].classList) {
                continue;
            }
            this.navigations[i].classList.remove('slider_navigation_active');
            if (this.navigations[i].dataset.slideId === this.slides[this.active_slide].id) {
                this.navigations[i].classList.add('slider_navigation_active');
            }
        }
    }
    scroll() {
        let offset = -100 * this.active_slide;

        for (let i = 0; i < this.slides.length; i++) {
            this.slides[i].style.left = offset + "%";
        }
    }
    moveNext() {
        this.active_slide++;
        if (this.slides_length <= this.active_slide) {
            this.active_slide = 0;
        }
        this.setSlidesClasses();
        this.setNavigationClasses();
        this.scroll();
    }
    movePrev() {
        this.active_slide--;
        if (this.active_slide < 0) {
            this.active_slide = this.slides_length - 1;
        }
        this.setSlidesClasses();
        this.setNavigationClasses();
        this.scroll();
    }
    moveNextButton() {
        this.resetInterval();
        this.moveNext();
    }
    movePrevButton() {
        this.resetInterval();
        this.movePrev();
    }
    moveButton(button) {
        this.resetInterval();
        let slide_id = button.dataset.slideId;
        for (let i = 0; i < this.slides_length; i++) {
            if (this.slides[i].id === slide_id) {
                this.active_slide = i;
                break;
            }
        }
        this.setSlidesClasses();
        this.setNavigationClasses();
        this.scroll();
    }
}

class Gallery {
    constructor(dialog_id, use_expand = false, max_expanded_collages = 1) {
        this.use_expand = use_expand;
        this.max_expanded_collages = max_expanded_collages;
        this.expanded_collages = [];
        this.expand_time = 800;
        this.selected_item = null;
        this.selected_element = null;
        this.dialog = null;
        this.dialog_content = null;
        this.dialog_btn_previous = null;
        this.dialog_btn_next = null;

        this.initialX = null;

        this.dialog = document.getElementById(dialog_id);

        let contents = this.dialog.getElementsByClassName('content');
        if (contents && contents.length === 1) {
            this.dialog_content = contents[0];

            this.dialog_content.addEventListener('touchstart', this.startTouch.bind(this));
            this.dialog_content.addEventListener('touchend', this.moveTouch.bind(this));

        }

        let btn_previous = this.dialog.getElementsByClassName('btn_previous');
        if (btn_previous && btn_previous.length === 1) {
            this.dialog_btn_previous = btn_previous[0];
            this.dialog_btn_previous.addEventListener('click', this.previousElement.bind(this));
        }

        let btn_next = this.dialog.getElementsByClassName('btn_next');
        if (btn_next && btn_next.length === 1) {
            this.dialog_btn_next = btn_next[0];
            this.dialog_btn_next.addEventListener('click', this.nextElement.bind(this));
        }

        let btn_close = this.dialog.getElementsByClassName('btn_close');
        if (btn_close && btn_close.length === 1) {
            btn_close[0].addEventListener('click', this.closeDialog.bind(this));
        }

        let collage_contents = this.dialog.parentNode.getElementsByClassName('collage_content');
        let collage_contents_length = collage_contents.length;
        for (let i = 0; i < collage_contents_length; i++) {
            collage_contents[i].onclick = null;
            collage_contents[i].addEventListener('click', this.showElementEvent.bind(this));
        }

        this.initExpand();
    }
    unify(e) { return e.changedTouches ? e.changedTouches[0] : e };
    startTouch(e) {
        this.initialX = this.unify(e).clientX;
    }
    moveTouch(e) {
        if (this.initialX === null) {
            return;
        }
        var currentX = this.unify(e).clientX;
        var diffX = this.initialX - currentX;
        if (diffX > 50) {


            this.nextElement();
        } else if (diffX < -50) {


            this.previousElement();
        }
        this.initialX = null;
        e.preventDefault();
    }
    initExpand() {
        if (!this.use_expand) {
            return;
        }

        let header_elements = this.dialog.parentNode.getElementsByClassName('gallery_collage_header');
        let header_elements_length = header_elements.length;
        if (!header_elements_length) {
            return;
        }


        let collage_elements = this.dialog.parentNode.getElementsByClassName('collage');
        let collage_elements_length = collage_elements.length;
        if (!collage_elements.length || header_elements_length !== collage_elements_length) {
            return;
        }


        for (let i = 0; i < collage_elements_length; i++) {
            header_elements[i].addEventListener('click', this.expandAction.bind(this, header_elements[i]));

            collage_elements[i].style.height = collage_elements[i].offsetHeight + 'px';
            if (header_elements[i].classList.contains('not_expanded')) {
                collage_elements[i].classList.add('not_expanded');
                continue;
            }
            this.expanded_collages.push(collage_elements[i]);
        }

    }
    expandAction(header_element) {
        if (!header_element.classList.contains('not_expanded')) {

            this.collapseAction(header_element);
            return;
        }
        let collage_element = document.getElementById('collage_' + header_element.dataset.collageId);
        if (!collage_element) {

            return;
        }

        header_element.classList.remove('not_expanded');
        collage_element.classList.remove('not_expanded');
        this.expanded_collages.push(collage_element);


        if (this.expanded_collages.length > this.max_expanded_collages) {
            let delete_count = this.expanded_collages.length - this.max_expanded_collages;
            for (let i = 0; i < delete_count; i++) {
                this.expanded_collages[i].classList.add('not_expanded');
                let header_element_to_hide = document.querySelector(
                    '.gallery_collage_header[data-collage-id="' + this.expanded_collages[i].dataset.id + '"]'
                );
                if (header_element_to_hide) {
                    header_element_to_hide.classList.add('not_expanded');
                }
            }
            this.expanded_collages.splice(0, delete_count);
        }


        setTimeout(function () {
            if (
                header_element.getBoundingClientRect().bottom > window.innerHeight ||
                header_element.getBoundingClientRect().top < 0
            ) {
                header_element.scrollIntoView({ behavior: "smooth", block: "start" });
            }
        }, this.expand_time);

    }
    collapseAction(header_element) {
        header_element.classList.add('not_expanded');
        let loops = this.expanded_collages.length;
        for (let i = 0; i < loops; i++) {
            if (this.expanded_collages[i].dataset.id === header_element.dataset.collageId) {
                this.expanded_collages[i].classList.add('not_expanded');
                this.expanded_collages.splice(i, 1);
                break;
            }
        }
    }
    openDialog() {
        this.dialog.classList.remove('hidden');
    }
    closeDialog() {
        this.dialog.classList.add('hidden');
        this.removeDialogChilds();
    }
    removeDialogChilds() {
        while (this.dialog_content.firstChild) {
            this.dialog_content.removeChild(this.dialog_content.firstChild);
        }
    }
    toggleButtons() {
        if (this.selected_item.previousElementSibling) {
            this.dialog_btn_previous.classList.remove('hidden');
        } else {
            this.dialog_btn_previous.classList.add('hidden');
        }
        if (this.selected_item.nextElementSibling) {
            this.dialog_btn_next.classList.remove('hidden');
        } else {
            this.dialog_btn_next.classList.add('hidden');
        }
    }
    showElementEvent(event) {
        let target = event.target;
        let closest = target.closest('.collage_content');
        if (closest) {
            this.showElement(closest);
        }
    }
    showElement(element) {
        this.selected_item = element.parentNode; // collage_item
        this.selected_element = element; // collage_content
        this.removeDialogChilds();
        let element_copy = this.selected_element.cloneNode(true);
        element_copy.classList.remove('collage_content');
        let article_content = element_copy.querySelector("[id^='article_content_']");
        if (article_content) {
            article_content.id = 'gallery_article_content';
        }
        let video_box = element_copy.querySelector("[id^='article_video_box_']");
        if (video_box) {
            video_box.id = 'gallery_article_video_box';
            element_copy.onclick = null;
            element_copy.addEventListener('click', function () {
                videoPlayOrPause('gallery_article_video_box', 'gallery_article_content');
            });
        }
        if (element_copy.children[0].tagName == 'VIDEO') {
            element_copy.children[0].controls = true;
        }
        this.dialog_content.appendChild(element_copy);
        this.toggleButtons();
        this.openDialog();
    }
    previousElement() {
        let sibling = this.selected_item.previousElementSibling;
        if (sibling) {
            let collage_contents = sibling.getElementsByClassName('collage_content');
            if (collage_contents && collage_contents.length === 1) {
                this.showElement(collage_contents[0]);
            }
        }
    }
    nextElement() {
        let sibling = this.selected_item.nextElementSibling;
        if (sibling) {
            let collage_contents = sibling.getElementsByClassName('collage_content');
            if (collage_contents && collage_contents.length === 1) {
                this.showElement(collage_contents[0]);
            }
        }
    }
}

function resizeGridItem(item){
    let grid = document.getElementsByClassName("grid")[0];
    let rowHeight = parseInt(window.getComputedStyle(grid).getPropertyValue('grid-auto-rows'));
    let rowGap = parseInt(window.getComputedStyle(grid).getPropertyValue('grid-row-gap'));
    let rowSpan = Math.ceil((item.querySelector('.content').getBoundingClientRect().height+rowGap)/(rowHeight+rowGap));
    item.style.gridRowEnd = "span "+rowSpan;
}
function resizeAllGridItems(){
    let allItems = document.getElementsByClassName("grid_item");
    let allItemsLength = allItems.length;
    for (let i = 0; i < allItemsLength; i++) {
        resizeGridItem(allItems[i]);
    }
}
function resizeInstance(instance){
    let item = instance.elements[0];
    resizeGridItem(item);
}

function sendDataBasic(params, url, target_element_id, refresh_page = true, successCallback = null) {
    let xmlhttp = new XMLHttpRequest();
    xmlhttp.onreadystatechange = function() {
        return function() {
            if (xmlhttp.readyState == 4 && xmlhttp.status == 200) {
                let result = xmlhttp.responseText.trim();

                if (result == '1') {

                    if(refresh_page) {
                        location.reload();
                    }
                    if(successCallback != null) {
                        successCallback();
                    }
                } else {
                    if(target_element_id != null) {
                        let el = document.getElementById(target_element_id);
                        el.classList.add('error');
                    }

                }
            }
        }
    }();
    xmlhttp.open('POST', url, true);
    xmlhttp.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
    xmlhttp.send(params);
}

function validateInputSetDefault(input_element, default_amount) {
    if (input_element.value == '') {
        input_element.value = default_amount;
    }
}
function changeValue(element_id, difference) {
    let element = document.getElementById(element_id);
    element.value = parseInt(element.value) + difference;
    validateInputInteger(element);
}

function validateInput(element, function_ok = null, function_ko = null) {
    if (!element.value || element.value.length == 0) {
        if (element.required) {
            if (function_ko !== null) {
                function_ko();
            }
            element.classList.add('error');
            return false;
        } else {
            if (function_ok !== null) {
                function_ok();
            }
            element.classList.remove('error');
            return true;
        }
    }
    if (element.pattern) {
        let pattern = new RegExp(element.pattern);
        if (!pattern.test(element.value)) {
            if (function_ko !== null) {
                function_ko();
            }
            element.classList.add('error');
            return false;
        }
    }
    if (function_ok !== null) {
        function_ok();
    }
    element.classList.remove('error');
    return true;
}
function validateForm(form) {
    let inputs = form.querySelectorAll('input');
    let success = true;
    let inputs_length = inputs.length;
    for (let i = 0; i < inputs_length; i++) {
        if (!verifyInput(inputs[i])) {
            inputs[i].classList.add('error');
            success = false;
        } else {
            inputs[i].classList.remove('error');
        }
    }
    return success;
}
function validateInputInteger(input_element) {
    if (input_element.value != '') {
        if (input_element.value < input_element.min) {
            input_element.value = input_element.min;
        } else {
            input_element.value = parseInt(input_element.value);
        }
    }
}
function redirect(target_url) {
    location.href = target_url;
}
function redirectByDataHref(element) {
    let href = element.dataset.href;
    if (href) {
        redirect(href);
    }
}

 class AutoCompleteMessenger extends Messenger {
    setSearchValue(search_value) {
        this.t_search_value = search_value;
    }
    getSearchValue() {
        return this.t_search_value;
    }
}




 class AutoCompleteController {
    constructor(page, autocomplete_html_id, action_name, use_autocomplete = true) {
        this.m_timer_id = null;
        this.m_component_id = null;
        this.m_page = page;
        this.m_action_send = action_name;
        let main_element = HtmlHelper.getElement(autocomplete_html_id);
        if (main_element === null) {
            return;
        }
        this.m_main_element = main_element;
        let element = HtmlHelper.getFirstOfClassInParent("autocomplete_input", main_element);
        if (element instanceof HTMLInputElement) {
            this.m_input_element = element;
            if (use_autocomplete === true) {
                this.m_input_element.addEventListener("input", e => {
                    this.m_input_element.classList.remove("error");
                    if (this.m_timer_id !== null) {
                        window.clearTimeout(this.m_timer_id);
                    }
                    let component_id = null;
                    if (this.m_input_element.dataset.id) {
                        component_id = this.m_input_element.dataset.id;
                    }
                    this.m_timer_id = window.setTimeout(this.findMessengers.bind(this), 350, this.m_input_element.value, this.m_input_element.dataset.id, this.renderMessengersSuccessCallback.bind(this), this.unexpectedErrorCallback.bind(this));
                });
            }
        }
        element = HtmlHelper.getFirstOfClassInParent("search_autocomplete_results", main_element);
        this.m_results_element = element;
    }
    renderMessengersSuccessCallback(api) {
        HtmlHelper.showElement(HtmlHelper.getFirstOfClassInParent("search_icon", this.m_main_element));
        HtmlHelper.hideElement(HtmlHelper.getFirstOfClassInParent("loading_icon", this.m_main_element));
        let message = api.getResult().getResult("message");
        if (message !== null) {
            let element = HtmlHelper.getFirstOfClassInParent("autocomplete_no_messengers_found", this.m_results_element);
            if (element !== null) {
                HtmlHelper.showElement(element);
                HtmlHelper.showElement(this.m_results_element);
            }
            return;
        }
        let messengers = api.getResult().getResult("messengers");
        if (messengers === null) {
            this.unexpectedErrorCallback();
            return;
        }
        HtmlHelper.showElement(this.m_results_element);
        let product_template_element = HtmlHelper.getFirstOfClassInParent("autocomplete_messenger_template", this.m_results_element);
        for (let index = 0; index < messengers.length; index++) {
            let copy = product_template_element.cloneNode(true);
            if (copy instanceof HTMLElement) {
                copy.classList.remove("hidden");
                copy.classList.add("autocomplete_messenger_clone");
                copy.id = "autocomplete_messenger_clone_" + index;
                this.transformMessengers(messengers[index], copy);
                this.m_results_element.appendChild(copy);
            }
        }
    }
    unexpectedErrorCallback() {
        let element = HtmlHelper.getFirstOfClassInParent("autocomplete_unexpected_error", this.m_results_element);
        if (element !== null) {
            HtmlHelper.showElement(element);
            HtmlHelper.showElement(this.m_results_element);
        }
        HtmlHelper.showElement(HtmlHelper.getFirstOfClassInParent("search_icon", this.m_main_element));
        HtmlHelper.hideElement(HtmlHelper.getFirstOfClassInParent("loading_icon", this.m_main_element));
    }
    findMessengers(searched_value, component_id = null, callback_success = null, callback_error = null, min_len = 2) {
        if (searched_value.length < min_len) {
            HtmlHelper.hideElement(this.m_results_element);
            return;
        }
        this.m_component_id = component_id;
        let elements = HtmlHelper.getAllOfClass("autocomplete_messenger_clone");
        if (elements !== null) {
            HtmlHelper.removeAllElements(elements);
        }
        elements = HtmlHelper.getAllOfClass("autocomplete_row", this.m_results_element);
        if (elements !== null) {
            HtmlHelper.hideAllElements(elements);
        }
        HtmlHelper.hideElement(this.m_results_element);
        let search_component_messenger = this.prepareFindMessenger();
        search_component_messenger.setSearchValue(UrlHelper.clean(searched_value));
        if (component_id !== null) {
            search_component_messenger.setId(component_id);
        }
        HtmlHelper.hideElement(HtmlHelper.getFirstOfClassInParent("search_icon", this.m_main_element));
        HtmlHelper.showElement(HtmlHelper.getFirstOfClassInParent("loading_icon", this.m_main_element));
        let api = new Api();
        api.sendData(search_component_messenger, this.m_action_send, this.m_page.getPageUrl(), false, callback_success, callback_error);
    }
    prepareFindMessenger() {
        return new AutoCompleteMessenger();
    }
}





 class SearchAutoCompleteController extends AutoCompleteController {
    constructor(page, autocomplete_html_id, action_name, use_autocomplete, use_submit_action_product, target_url_name) {
        super(page, autocomplete_html_id, action_name, use_autocomplete);
        if (use_submit_action_product === true) {
            let button_element = HtmlHelper.getElement("search_button_" + this.m_input_element.dataset.id);
            if (button_element !== null) {
                HtmlHelper.showElement(button_element);
                button_element.addEventListener("click", e => {
                    if (this.m_input_element.value.length <= 2) {
                        return;
                    }
                    window.location.href = this.m_page.getLocalAbsUrl() + target_url_name + "/" + "q" + "/" + UrlHelper.clean(this.m_input_element.value);
                });
            }
            this.m_input_element.addEventListener("keypress", e => {
                if (e.key !== "Enter") {
                    return;
                }
                if (this.m_input_element.value.length <= 2) {
                    return;
                }
                window.location.href = this.m_page.getLocalAbsUrl() + target_url_name + "/" + "q" + "/" + UrlHelper.clean(this.m_input_element.value);
            });
        }
    }
    setTextToFirstElementOfClassInParent(class_name, parent, text) {
        let element = HtmlHelper.getFirstOfClassInParent(class_name, parent);
        if (element instanceof HTMLElement) {
            element.innerText = text;
        }
    }
    transformMessengers(messenger, copy) {
        let product_messenger = new ProductMessenger();
        product_messenger.deserialize(messenger);
        if (copy instanceof HTMLAnchorElement) {
            let product_url_name = product_messenger.getUrlName();
            if (product_url_name == null) {
                product_url_name = product_messenger.getOrigProductId().toString();
            }
            copy.href = this.m_page.getLocalAbsUrl() + "produkt" + "/" + product_messenger.getUrlName();
        }
        this.setTextToFirstElementOfClassInParent("search_autocomplete_product_name", copy, product_messenger.getName());
        this.setTextToFirstElementOfClassInParent("search_autocomplete_product_price_without_vat_value", copy, PriceHelper.formatPrice(product_messenger.getPrice(), product_messenger.getCurrencyId().getName()));
        this.setTextToFirstElementOfClassInParent("search_autocomplete_product_price", copy, PriceHelper.formatPrice(product_messenger.getPriceVat(), product_messenger.getCurrencyId().getName()));
        if (product_messenger.getIconFile() !== null) {
            let element = HtmlHelper.getFirstOfClassInParent("search_autocomplete_product_icon", copy);
            if (element instanceof HTMLImageElement) {
                element.src = product_messenger.getIconFile().getIconUrl().toString();
            }
        }
    }
}

class Api {
    constructor() {
        this.m_raw_result = "";
    }
    parseResult(result_string) {
        this.m_result = new Result();
        let result_json;
        try {
            result_json = JSON.parse(result_string);
        }
        catch (e) {
            return false;
        }
        if ('results' in result_json) {
            this.m_result.setResults(result_json['results']);
        }
        if ('errors' in result_json) {
            this.m_result.setErrors(result_json['errors']);
        }
        if ('id' in result_json) {
            this.m_result.setId(result_json['id']);
        }
        if ('signature' in result_json) {
            this.m_result.setSignature(result_json['signature']);
        }
        if ('error_messages' in result_json) {
            this.m_result.setErrorMessages(result_json['error_messages']);
        }
        return this.m_result.isSuccess();
    }
    transformMessenger(serialized, prefix = null, level = 0) {
        if (level > 5) {
            return "";
        }
        let result = "";
        let keys = Object.keys(serialized);
        let real_prefix;
        if (prefix === null) {
            real_prefix = keys[0];
        }
        else {
            real_prefix = prefix + '[' + keys[0] + ']';
        }
        serialized = serialized[keys[0]];
        keys = Object.keys(serialized);
        let i_max = keys.length;
        for (let i = 0; i < i_max; i++) {
            let value = serialized[keys[i]];
            let current_key = real_prefix + '[' + keys[i] + ']';
            let add_key = true;
            let add_value;
            if (value === null) {
                add_value = Api.NULL;
            }
            else if (typeof value === 'object') {
                let inner_keys = Object.keys(value);
                let inner_keys_length = inner_keys.length;
                let is_messenger = false;
                if (inner_keys_length === 1) {
                    let inner_messenger_name = inner_keys[0];
                    if (inner_messenger_name.includes('Messenger')) {
                        is_messenger = true;
                        add_key = false;
                        add_value = this.transformMessenger(value, current_key, level + 1);
                    }
                }
                if (!is_messenger) {
                    if (inner_keys_length === 0) {
                        continue;
                    }
                    let is_messengers_array = false;
                    let inner_inner_keys0 = Object.keys(value[inner_keys[0]]);
                    if (inner_inner_keys0.length === 1 && inner_inner_keys0[0].includes('Messenger')) {
                        is_messengers_array = true;
                    }
                    add_key = false;
                    add_value = '';
                    for (let j = 0; j < inner_keys_length; j++) {
                        if (is_messengers_array) {
                            add_value += this.transformMessenger(value[inner_keys[j]], current_key + '[' + inner_keys[j] + ']', level + 1);
                        }
                        else {
                            add_value += '&';
                            add_value += current_key + '[' + inner_keys[j] + ']';
                            add_value += '=';
                            add_value += encodeURIComponent(value[inner_keys[j]]);
                        }
                    }
                }
            }
            else {
                add_value = encodeURIComponent(value);
            }
            if (add_key) {
                result += '&' + current_key;
                result += "=";
            }
            result += add_value;
        }
        return result;
    }
    sendDataBasic(params, url, refresh_page = false, callback_success = null, callback_error = null, target_element_id = null) {
        let xmlhttp = new XMLHttpRequest();
        xmlhttp.onerror = (e) => {
            if (target_element_id != null) {
                let el = document.getElementById(target_element_id);
                el.classList.add('error');
            }
            if (callback_error != null) {
                callback_error(this);
            }
        };
        xmlhttp.onreadystatechange = () => {
            if (xmlhttp.readyState != XMLHttpRequest.DONE) {
                return;
            }
            let success = false;
            this.m_raw_result = xmlhttp.responseText;
            if (xmlhttp.readyState == XMLHttpRequest.DONE && xmlhttp.status == 200) {
                success = this.parseResult(this.m_raw_result);
            }
            if (success) {
                if (callback_success != null) {
                    callback_success(this);
                }
                if (refresh_page) {
                    location.reload();
                }
            }
            else {
                if (callback_error != null) {
                    callback_error(this);
                }
                if (target_element_id != null) {
                    let el = document.getElementById(target_element_id);
                    el.classList.add('error');
                }
            }
        };
        xmlhttp.open('POST', url, true);
        xmlhttp.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
        xmlhttp.send(params);
    }
    sendData(messenger, action, url, refresh_page = false, callback_success = null, callback_error = null, target_element_id = null) {
        this.sendDataMany([messenger], action, url, refresh_page, callback_success, callback_error, target_element_id);
    }
    sendDataMany(messengers, action, url, refresh_page = false, callback_success = null, callback_error = null, target_element_id = null) {
        let params = action;
        let messengers_length = messengers.length;
        for (let i = 0; i < messengers_length; i++) {
            let serialized_messenger = messengers[i].serialize();
            params += this.transformMessenger(serialized_messenger, null) + '&';
        }
        params = params.slice(0, -1);
        this.sendDataBasic(params, url, refresh_page, callback_success, callback_error, target_element_id);
    }
    getRawResult() {
        return this.m_raw_result;
    }
    getResult() {
        return this.m_result;
    }
}
Api.NULL = '$null$';
 Api;
 class Result {
    constructor() {
        this.results = {
            success: false,
        };
        this.errors = {
            incorrectData: false,
            noSuchRequest: false,
            dbConn: false,
            auth: false,
            authUser: false,
            dbQuery: false,
        };
        this.id = '1';
        this.signature = 'null';
        this.error_messages = new Array();
    }
    setResults(results) {
        this.results = results;
    }
    addResult(key, data) {
        this.results[key] = data;
    }
    getResult(key) {
        if (key in this.results) {
            return this.results[key];
        }
        return null;
    }
    getResults() {
        return this.results;
    }
    isSuccess() {
        if ('success' in this.results) {
            return this.results.success === true;
        }
        return false;
    }
    setErrors(errors) {
        this.errors = errors;
    }
    addError(key, state = true) {
        this.errors[key] = state;
    }
    getError(key) {
        if (key in this.errors) {
            return this.errors[key];
        }
        return null;
    }
    setId(id) {
        this.id = id;
    }
    getId() {
        return this.id;
    }
    setSignature(signature) {
        this.signature = signature;
    }
    getSignature() {
        return this.signature;
    }
    addErrorMessage(message) {
        if (this.error_messages.includes(message)) {
            return;
        }
        this.error_messages.push(message);
    }
    setErrorMessages(messages) {
        this.error_messages = messages;
    }
    getErrorMessages() {
        return this.error_messages;
    }
}



 class CartButtonController {
    constructor(button_type, button_id, order_pieces) {
        this.m_use_total_price = false;
        this.m_total_price = 0;
        this.m_currency = "Kč";
        this.m_button_type = button_type;
        this.m_button_id = button_id;
        this.m_order_pieces = order_pieces;
    }
    initButtonElement() {
        let button_html_id = '';
        if (this.m_button_type === 1) {
            button_html_id += 'menu_link_button_';
        }
        else {
            button_html_id += 'menu_internal_button_';
        }
        button_html_id += this.m_button_id;
        this.m_button_element = document.getElementById(button_html_id);
        this.m_button_element.classList.add('cart_button');
        let cart_empty_class = this.getOrderPieces() > 0 ? 'cart_not_empty' : 'cart_empty';
        this.m_button_element.classList.add(cart_empty_class);
    }
    processCartButtonData(api) {
        this.setOrderPieces(api.getResult().getResult("cart_button_amount"));
        this.setTotalPrice(api.getResult().getResult("cart_button_total_price"));
        this.setUseTotalPrice(api.getResult().getResult("cart_button_use_total_price"));
        this.initButtonElement();
        if (this.m_order_pieces > 0) {
            this.render();
        }
    }
    setUseTotalPrice(use_total_price) {
        this.m_use_total_price = use_total_price;
    }
    getUseTotalPrice() {
        return this.m_use_total_price;
    }
    setTotalPrice(total_price) {
        this.m_total_price = total_price;
        this.render();
    }
    addTotalPrice(added_price) {
        this.m_total_price += added_price;
        this.render();
    }
    getTotalPrice() {
        return this.m_total_price;
    }
    setOrderPieces(order_pieces) {
        this.m_order_pieces = order_pieces;
        this.render();
    }
    addOrderPieces(added_pieces) {
        this.m_order_pieces += added_pieces;
        this.render();
    }
    getOrderPieces() {
        return this.m_order_pieces;
    }
    render() {
        if (!this.m_button_element) {
            return;
        }
        if (this.getOrderPieces() > 0) {
            this.m_button_element.classList.remove('cart_empty');
            this.m_button_element.classList.add('cart_not_empty');
        }
        else {
            this.m_button_element.classList.remove('cart_not_empty');
            this.m_button_element.classList.add('cart_empty');
        }
        let span = this.m_button_element.getElementsByTagName('span')[0];
        span.classList.add('cart_button_quantity');
        span.textContent = this.m_order_pieces.toString();
        if (this.m_use_total_price === true) {
            let span_price = document.getElementById('cart_button_price');
            if (!span_price) {
                span_price = document.createElement('span');
                span_price.id = 'cart_button_price';
                span_price.classList.add('cart_button_price');
                span.parentNode.append(span_price);
            }
            span_price.textContent = ' (' + PriceHelper.formatPrice(this.m_total_price, this.m_currency, true) + ')';
        }
    }
    getCartButtonDataAction() {
        let api = new Api();
        let messenger = new Messenger();
        api.sendData(messenger, 'get_cart_button_data', window.location.href, false, this.processCartButtonData.bind(this), null);
    }
}


















class OrderFormApiController {
    constructor(page, cart_button_controller) {
        this.m_add_product_counts = {};
        this.m_add_product_timeouts = {};
        this.m_set_product_amount_counts = {};
        this.m_set_product_amount_timeouts = {};
        this.m_page = page;
        this.m_cart_button_controller = cart_button_controller;
    }
    addProductCall(key, callback_success = null, callback_error = null) {
        this.m_add_product_timeouts[key] = null;
        let messenger = this.m_add_product_counts[key];
        this.m_add_product_counts[key] = null;
        let api = new Api();
        api.sendData(messenger, 'add_product', this.m_page.getPageUrl(), false, callback_success, callback_error);
    }
    setProductAmountCall(product_id, callback_success = null, callback_error = null) {
        this.m_set_product_amount_timeouts[product_id] = null;
        let messenger = this.m_set_product_amount_counts[product_id];
        this.m_set_product_amount_counts[product_id] = null;
        let api = new Api();
        api.sendData(messenger, 'set_product_amount', this.m_page.getPageUrl(), false, callback_success, callback_error);
    }
    static showErrorMessages(api) {
        let error_messages = api.getResult().getErrorMessages();
        let error_messages_length = error_messages.length;
        for (let i = 0; i < error_messages_length; i++) {
            HtmlHelper.newErrorMessageElement(error_messages[i]);
        }
    }
    addProduct(product_id, product_amount, product_price_vat, check_variants = false, callback_success = null, callback_error = null) {
        let product_key = '';
        let variant_parameter_to_product_messengers = new Array();
        product_key += product_id + ';';
        if (check_variants) {
            let variant_parameter_elements = document.getElementsByClassName('variant_parameter_value');
            let variant_parameter_elements_length = variant_parameter_elements.length;
            for (let i = 0; i < variant_parameter_elements_length; i++) {
                let variant_parameter_element = variant_parameter_elements[i];
                let variant_id = null;
                let value = null;
                if (!(variant_parameter_element instanceof HTMLElement)) {
                    continue;
                }
                switch (Number(variant_parameter_element.dataset.type)) {
                    case 1:
                        if (!(variant_parameter_element instanceof HTMLInputElement)) {
                            continue;
                        }
                        if (!variant_parameter_element.checked) {
                            continue;
                        }
                        variant_id = variant_parameter_element.value;
                        break;
                    case 2:
                        if (!(variant_parameter_element instanceof HTMLSelectElement)) {
                            continue;
                        }
                        variant_id = variant_parameter_element.value;
                        break;
                    case 3:
                        if (!(variant_parameter_element instanceof HTMLInputElement)) {
                            continue;
                        }
                        if (variant_parameter_element.value.trim() == "") {
                            continue;
                        }
                        variant_id = variant_parameter_element.dataset.defaultId;
                        value = variant_parameter_element.value;
                        break;
                    default:
                        continue;
                }
                let category_messenger = new CategoryMessenger();
                category_messenger.setId(Number(variant_parameter_element.dataset.categoryId));
                let variant_parameter_to_product_messenger = new VariantParameterToProductMessenger();
                variant_parameter_to_product_messenger.setId(Number(variant_id));
                if (value != null) {
                    variant_parameter_to_product_messenger.setValue(value);
                }
                variant_parameter_to_product_messenger.setChildCategoryId(category_messenger);
                variant_parameter_to_product_messengers.push(variant_parameter_to_product_messenger);
                product_key += variant_parameter_to_product_messenger.getId() + ';';
            }
        }
        if (!(product_key in this.m_add_product_counts) || this.m_add_product_counts[product_key] === null) {
            let order_form_api_product_messenger = new OrderFormApiProductMessenger();
            order_form_api_product_messenger.setCount(product_amount);
            if (check_variants) {
                order_form_api_product_messenger.setVariantParameters(variant_parameter_to_product_messengers);
            }
            let product_messenger = new ProductMessenger();
            product_messenger.setId(product_id);
            order_form_api_product_messenger.setProduct(product_messenger);
            this.m_add_product_counts[product_key] = order_form_api_product_messenger;
        }
        if (product_key in this.m_add_product_timeouts && this.m_add_product_timeouts[product_key] !== null) {
            clearTimeout(this.m_add_product_timeouts[product_key]);
            this.m_add_product_counts[product_key].addCount(product_amount);
        }
        this.m_add_product_timeouts[product_key] = setTimeout(this.addProductCall.bind(this, product_key, callback_success, callback_error), OrderFormApiController.TIMEOUTS_DELAY);
        if (this.m_cart_button_controller) {
            this.m_cart_button_controller.addOrderPieces(product_amount);
            this.m_cart_button_controller.addTotalPrice(product_price_vat * product_amount);
        }
    }
    setProductAmount(product_id, product_amount, callback_success = null, callback_error = null) {
        if (!(product_id in this.m_set_product_amount_counts) || this.m_set_product_amount_counts[product_id] === null) {
            let order_form_api_product_messenger = new OrderFormApiProductMessenger();
            order_form_api_product_messenger.setCount(product_amount);
            let product_messenger = new ProductMessenger();
            product_messenger.setId(product_id);
            order_form_api_product_messenger.setProduct(product_messenger);
            this.m_set_product_amount_counts[product_id] = order_form_api_product_messenger;
        }
        if (product_id in this.m_set_product_amount_timeouts && this.m_set_product_amount_timeouts[product_id] !== null) {
            clearTimeout(this.m_set_product_amount_timeouts[product_id]);
            this.m_set_product_amount_counts[product_id].setCount(product_amount);
        }
        this.m_set_product_amount_timeouts[product_id] = setTimeout(this.setProductAmountCall.bind(this, product_id, callback_success, callback_error), OrderFormApiController.TIMEOUTS_DELAY);
    }
    deleteProduct(product_id, callback_success = null, callback_error = null) {
        let product_messenger = new ProductMessenger();
        product_messenger.setId(product_id);
        let api = new Api();
        api.sendData(product_messenger, 'delete_product', this.m_page.getPageUrl(), false, callback_success, callback_error);
    }
    setDeliveryType(delivery_type_id, callback_success = null, callback_error = null) {
        let delivery_type_messenger = new DeliveryTypeMessenger();
        delivery_type_messenger.setId(delivery_type_id);
        let api = new Api();
        api.sendData(delivery_type_messenger, 'set_delivery_type_id', this.m_page.getPageUrl(), false, callback_success, callback_error);
    }
    setPaymentType(payment_type_id, callback_success = null, callback_error = null) {
        let payment_type_messenger = new PaymentTypeMessenger();
        payment_type_messenger.setId(payment_type_id);
        let api = new Api();
        api.sendData(payment_type_messenger, 'set_payment_type_id', this.m_page.getPageUrl(), false, callback_success, callback_error);
    }
    setDeliveryTimeType(delivery_time_type_id, callback_success = null, callback_error = null) {
        let delivery_time_type_messenger = new DeliveryTimeTypeMessenger();
        delivery_time_type_messenger.setId(delivery_time_type_id);
        let api = new Api();
        api.sendData(delivery_time_type_messenger, 'set_delivery_time_type', this.m_page.getPageUrl(), false, callback_success, callback_error);
    }
    setDeliveryTimes(delivery_date, delivery_time, callback_success = null, callback_error = null) {
        let order_messenger = new OrderMessenger();
        if (delivery_date !== null) {
            order_messenger.setDeliveryDate(delivery_date);
        }
        if (delivery_time !== null) {
            order_messenger.setDeliveryTime(delivery_time);
        }
        let api = new Api();
        api.sendData(order_messenger, 'set_delivery_times', this.m_page.getPageUrl(), false, callback_success, callback_error);
    }
    setBranch(branch_id, callback_success = null, callback_error = null) {
        let branch_messenger = new OurBranchMessenger();
        branch_messenger.setId(branch_id);
        let api = new Api();
        api.sendData(branch_messenger, 'set_branch', this.m_page.getPageUrl(), false, callback_success, callback_error);
    }
    setCarrierBranch(carrier_branch_id, callback_success = null, callback_error = null) {
        let branch_messenger = new BranchMessenger();
        branch_messenger.setId(carrier_branch_id);
        let api = new Api();
        api.sendData(branch_messenger, 'set_carrier_branch', this.m_page.getPageUrl(), false, callback_success, callback_error);
    }
    addDiscountCoupon(discount_coupon_code, refresh_page = false, callback_success = null, callback_error = null) {
        let discount_coupon_messenger = new DiscountCouponMessenger();
        discount_coupon_messenger.setCode(discount_coupon_code);
        let api = new Api();
        api.sendData(discount_coupon_messenger, 'add_discount_coupon', this.m_page.getPageUrl(), refresh_page, callback_success, callback_error);
    }
    deleteDiscountCoupon(discount_coupon_id, callback_success = null, callback_error = null) {
        let discount_coupon_messenger = new DiscountCouponMessenger();
        discount_coupon_messenger.setId(discount_coupon_id);
        let api = new Api();
        api.sendData(discount_coupon_messenger, 'delete_discount_coupon', this.m_page.getPageUrl(), false, callback_success, callback_error);
    }
    checkOrderState(state_id, order_token, refresh_page = false, callback_success = null, callback_error = null) {
        let order_state_messenger = new OrderStateMessenger();
        order_state_messenger.setId(state_id);
        let api = new Api();
        api.sendData(order_state_messenger, 'check_order_state', this.m_page.getPageUrl() + '/obj/' + order_token, refresh_page, callback_success, callback_error);
    }
    finishOrder(callback_success = null, callback_error = null) {
        let element;
        let send_data = new Array();
        let user_messenger = new UserMessenger();
        let contact_messenger = new ContactMessenger();
        let delivery_address_messenger;
        let invoice_address_messenger;
        contact_messenger.setName(HtmlHelper.getElementValue('contact_name'));
        contact_messenger.setSurname(HtmlHelper.getElementValue('contact_surname'));
        contact_messenger.setTelephone(HtmlHelper.getElementValue('contact_phone'));
        contact_messenger.setEmail(HtmlHelper.getElementValue('contact_email'));
        element = document.getElementById('contact_street_delivery');
        if (element) {
            delivery_address_messenger = new AddressMessenger();
            delivery_address_messenger.setStreet(HtmlHelper.getElementValue('contact_street_delivery'));
            delivery_address_messenger.setNoHouse(HtmlHelper.getElementValue('contact_street_num_delivery'));
            delivery_address_messenger.setPostcode(HtmlHelper.getElementValue('contact_post_code_delivery'));
            let city_messenger = new CityMessenger();
            city_messenger.setName(HtmlHelper.getElementValue('contact_city_delivery'));
            delivery_address_messenger.setCityId(city_messenger);
        }
        element = document.getElementById('invoice_address_same');
        if (element && element instanceof HTMLInputElement && element.checked) {
            invoice_address_messenger = delivery_address_messenger;
        }
        else {
            invoice_address_messenger = new AddressMessenger();
            invoice_address_messenger.setStreet(HtmlHelper.getElementValue('contact_street'));
            invoice_address_messenger.setNoHouse(HtmlHelper.getElementValue('contact_street_num'));
            invoice_address_messenger.setPostcode(HtmlHelper.getElementValue('contact_post_code'));
            let city_messenger = new CityMessenger();
            city_messenger.setName(HtmlHelper.getElementValue('contact_city'));
            invoice_address_messenger.setCityId(city_messenger);
        }
        user_messenger.setEmail(HtmlHelper.getElementValue('contact_email'));
        user_messenger.setMainContact(contact_messenger);
        user_messenger.setDeliveryAddressId(delivery_address_messenger);
        user_messenger.setInvoiceAddressId(invoice_address_messenger);
        element = document.getElementById('buy_on_company');
        if (element && element instanceof HTMLInputElement) {
            console.dir(element);
            user_messenger.setBuyOnCompany(element.checked);
            if (element.checked) {
                user_messenger.setIc(HtmlHelper.getElementValue('company_ico'));
                user_messenger.setDic(HtmlHelper.getElementValue('company_dic'));
                user_messenger.setCompanyName(HtmlHelper.getElementValue('company_name'));
                element = document.getElementById('company_vat');
                if (element && element instanceof HTMLInputElement) {
                    user_messenger.setVat(element.checked);
                }
            }
        }
        send_data.push(user_messenger);
        let value = HtmlHelper.getTextAreaValue('order_note');
        if (value !== null) {
            let order_messenger = new OrderMessenger();
            order_messenger.setDescription(value);
            send_data.push(order_messenger);
        }
        let branch_elements = document.getElementsByClassName('branch_input');
        let branch_elements_length = branch_elements.length;
        for (let i = 0; i < branch_elements_length; i++) {
            let branch_element = branch_elements[i];
            if (branch_element instanceof HTMLInputElement && branch_element.checked) {
                let messenger;
                if (branch_element.name == "branch") {
                    messenger = new OurBranchMessenger();
                }
                else if (branch_element.name == "carrier_branch") {
                    messenger = new BranchMessenger();
                }
                else {
                    continue;
                }
                messenger.setId(Number(branch_element.value));
                send_data.push(messenger);
                break;
            }
        }
        let api = new Api();
        api.sendDataMany(send_data, 'finish_order', this.m_page.getPageUrl(), false, callback_success, callback_error);
    }
}
OrderFormApiController.TIMEOUTS_DELAY = 200;
 OrderFormApiController;

 class OrderFormApiProductMessenger extends Messenger {
    setProduct(product) {
        this.t_product = product;
    }
    getProduct() {
        return this.t_product;
    }
    addVariantParameter(variant_parameter) {
        if (!this.t_variant_parameters) {
            this.t_variant_parameters = new Array();
        }
        this.t_variant_parameters.push(variant_parameter);
    }
    setVariantParameters(variant_parameters) {
        this.t_variant_parameters = variant_parameters;
    }
    getVariantParameters() {
        return this.t_variant_parameters;
    }
    addCount(count) {
        if (!this.t_count) {
            this.t_count = 0;
        }
        this.t_count += count;
    }
    setCount(count) {
        this.t_count = count;
    }
    getCount() {
        return this.t_count;
    }
}




 class VariantParametersController {
    constructor(page) {
        if (page instanceof Product) {
            this.m_page = page;
        }
    }
    sendProductVariant(product_id, use_amount, price, successCallback = null) {
        let amount = 1;
        if (use_amount === true) {
            let amount_element = HtmlHelper.getElement('amount');
            if (amount_element !== null) {
                if (amount_element instanceof HTMLInputElement) {
                    amount = parseInt(amount_element.value);
                }
            }
        }
        let product_price_element = HtmlHelper.getFirstOfClass('product-price');
        if (product_price_element !== null) {
            price = parseFloat(product_price_element.dataset.priceReal);
        }
        this.m_page.p_order_form_api_controller.addProduct(product_id, amount, price, true, successCallback, OrderFormApiController.showErrorMessages);
    }
    variantParameterShowCategories(header_element) {
        let hide_all = false;
        if (header_element.classList.contains('values_visible')) {
            hide_all = true;
        }
        let values_elements = HtmlHelper.getAllOfClass('variant_parameter_values');
        let loops = values_elements.length;
        for (let i = 0; i < loops; i++) {
            let value_element = values_elements[i];
            if (value_element instanceof HTMLElement) {
                if (hide_all || value_element.dataset.categoryId != header_element.dataset.categoryId) {
                    HtmlHelper.hideElement(value_element);
                }
                else {
                    HtmlHelper.showElement(value_element);
                }
            }
        }
        let headers = document.getElementsByClassName('variant_parameter_header');
        loops = headers.length;
        for (let i = 0; i < loops; i++) {
            headers[i].classList.remove('values_visible');
        }
        if (!hide_all) {
            header_element.classList.add('values_visible');
        }
        if (header_element.getBoundingClientRect().bottom > window.innerHeight ||
            header_element.getBoundingClientRect().top < 0) {
            header_element.scrollIntoView({ behavior: "smooth", block: "start" });
        }
    }
    variantParameterValueSelected(radio_element) {
        let label_element = document.querySelector('label[for="' + radio_element.id + '"] .variant_parameter_text_wrapper .variant_parameter_name');
        let header_text_element = document.querySelector('.variant_parameter_header[data-category-id="' + radio_element.dataset.categoryId + '"] .header_value_text');
        header_text_element.textContent = label_element.textContent;
        this.m_page.recalcPrices();
    }
    initSelectedVariantParameters() {
        let elements = HtmlHelper.getAllOfClass('variant_parameter_default');
        if (elements === null) {
            return;
        }
        let i_max = elements.length;
        let i = 0;
        while (i < i_max) {
            let element = elements[i];
            if (element instanceof HTMLElement) {
                element.click();
            }
            i++;
        }
        let url_param = UrlHelper.getUrlParam("v_s");
        if (url_param === null) {
            return;
        }
        let url_params = url_param.split(';');
        i_max = url_params.length - 1;
        i = 0;
        while (i < i_max) {
            let variant_css_class_id = "variant_parameter_" + url_params[i];
            let variant_element = HtmlHelper.getFirstOfClass(variant_css_class_id);
            if (variant_element !== null) {
                variant_element.click();
            }
            i++;
        }
    }
}

 class FileMessengerV4 extends Messenger {
    setName(name) {
        this.t_name = name;
    }
    getName() {
        return this.t_name;
    }
    setOriginalName(original_name) {
        this.t_original_name = original_name;
    }
    getOriginalName() {
        return this.t_original_name;
    }
    setCleanName(clean_name) {
        this.t_clean_name = clean_name;
    }
    getCleanName() {
        return this.t_clean_name;
    }
    setMimeType(mime_type) {
        this.t_mime_type = mime_type;
    }
    getMimeType() {
        return this.t_mime_type;
    }
    setMd5Code(md5_code) {
        this.t_md5_code = md5_code;
    }
    getMd5Code() {
        return this.t_md5_code;
    }
    setPublic(is_public) {
        this.t_public = is_public;
    }
    getPublic() {
        return this.t_public;
    }
    setBatchFolder(batch_folder) {
        this.t_batch_folder = batch_folder;
    }
    getBatchFolder() {
        return this.t_batch_folder;
    }
    setUrl(url) {
        this.t_url = url;
    }
    getUrl() {
        return this.t_url;
    }
    setIconUrl(icon_url) {
        this.t_icon_url = icon_url;
    }
    getIconUrl() {
        return this.t_icon_url;
    }
    setIsRemote(is_remote) {
        this.t_is_remote = is_remote;
    }
    getIsRemote() {
        return this.t_is_remote;
    }
}

 class PriceHelper {
    static formatPrice(price, currency_name, force_decimals = false) {
        let price_formatted = '';
        if (Number(price.toFixed(0)) != price || force_decimals) {
            price_formatted += price.toLocaleString('cs', {
                minimumFractionDigits: 2,
                maximumFractionDigits: 2,
            });
        }
        else {
            price_formatted += price.toLocaleString('cs', {
                maximumFractionDigits: 0,
            });
        }
        return price_formatted + ' ' + currency_name;
    }
    static calculatePriceWithVat(vat, price_without_vat) {
        return Math.ceil(price_without_vat * (1 + vat / 100) * 100) / 100;
    }
    static calculatePriceWithoutVat(vat, price_with_vat) {
        if (vat === 0) {
            return price_with_vat;
        }
        return Math.ceil(price_with_vat / (1 + vat / 100) * 100) / 100;
    }
    static calculateVatPricesOnVatChanged(parent_element = document) {
        console.log(parent_element);
        let element_price_vat = HtmlHelper.getFirstOfClassInputInParent("price_vat_input", parent_element);
        if (element_price_vat === null) {
            return;
        }
        let element_no_vat = HtmlHelper.getFirstOfClassInputInParent("price_input", parent_element);
        if (element_no_vat === null) {
            return;
        }
        let element_vat = HtmlHelper.getFirstOfClassInParent("vat_input", parent_element);
        if (element_vat === null) {
            return;
        }
        if (element_vat instanceof HTMLSelectElement) {
            let price = parseFloat(element_no_vat.value);
            let price_with_vat = parseFloat(element_price_vat.value);
            let vat = parseFloat(element_vat.value);
            element_price_vat.value = PriceHelper.calculatePriceWithVat(vat, price).toString();
        }
    }
    static onPriceWithoutVatChanged(parent_element = document) {
        let element_price_vat = HtmlHelper.getFirstOfClassInputInParent("price_vat_input", parent_element);
        if (element_price_vat === null) {
            return;
        }
        let element_no_vat = HtmlHelper.getFirstOfClassInputInParent("price_input", parent_element);
        if (element_no_vat === null) {
            return;
        }
        let element_vat = HtmlHelper.getFirstOfClassInParent("vat_input", parent_element);
        if (element_vat === null) {
            return;
        }
        if (element_vat instanceof HTMLSelectElement) {
            let price = parseFloat(element_no_vat.value);
            let price_with_vat = parseFloat(element_price_vat.value);
            let vat = parseFloat(element_vat.value);
            element_price_vat.value = PriceHelper.calculatePriceWithVat(vat, price).toString();
        }
    }
    static onPriceWithVatChanged(parent_element = document) {
        let element_price_vat = HtmlHelper.getFirstOfClassInputInParent("price_vat_input", parent_element);
        if (element_price_vat === null) {
            return;
        }
        let element_no_vat = HtmlHelper.getFirstOfClassInputInParent("price_input", parent_element);
        if (element_no_vat === null) {
            return;
        }
        let element_vat = HtmlHelper.getFirstOfClassInParent("vat_input", parent_element);
        if (element_vat === null) {
            return;
        }
        if (element_vat instanceof HTMLSelectElement) {
            let price = parseFloat(element_no_vat.value);
            let price_with_vat = parseFloat(element_price_vat.value);
            let vat = parseFloat(element_vat.value);
            element_no_vat.value = PriceHelper.calculatePriceWithoutVat(vat, price_with_vat).toString();
        }
    }
}

 class OrderStateMessenger extends Messenger {
}

 class DiscountCouponMessenger extends Messenger {
    setCode(code) {
        this.t_code = code;
    }
    getCode() {
        return this.t_code;
    }
    setDiscountValue(discount_value) {
        this.t_discount_value = discount_value;
    }
    getDiscountValue() {
        return this.t_discount_value;
    }
    setDiscountType(discount_type) {
        this.t_discount_type = discount_type;
    }
    getDiscountType() {
        return this.t_discount_type;
    }
}

 class BranchMessenger extends Messenger {
    setName(name) {
        this.t_name = name;
    }
    getName() {
        return this.t_name;
    }
    setDescription(description) {
        this.t_description = description;
    }
    getDescription() {
        return this.t_description;
    }
    setAddressId(address_id) {
        this.t_address_id = address_id;
    }
    getAddressId() {
        return this.t_address_id;
    }
}

 class OrderMessenger extends Messenger {
    setDescription(description) {
        this.t_description = description;
    }
    getDescription() {
        return this.t_description;
    }
    setDeliveryTime(delivery_time) {
        this.t_delivery_time = delivery_time;
    }
    getDeliveryTime() {
        return this.t_delivery_time;
    }
    setDeliveryDate(delivery_date) {
        this.t_delivery_date = delivery_date;
    }
    getDeliveryDate() {
        return this.t_delivery_date;
    }
}

 class PaymentTypeMessenger extends Messenger {
}

 class DeliveryTypeMessenger extends Messenger {
    setName(name) {
        this.t_name = name;
    }
    getName() {
        return this.t_name;
    }
}

 class ProductMessenger extends Messenger {
    setOrigProductId(orig_product_id) {
        this.t_orig_product_id = orig_product_id;
    }
    getOrigProductId() {
        return this.t_orig_product_id;
    }
    setName(name) {
        this.t_name = name;
    }
    getName() {
        return this.t_name;
    }
    setUrlName(url_name) {
        this.t_url_name = url_name;
    }
    getUrlName() {
        return this.t_url_name;
    }
    setPrice(price) {
        this.t_price = price;
    }
    getPrice() {
        return this.t_price;
    }
    setPriceVat(price_vat) {
        this.t_price_vat = price_vat;
    }
    getPriceVat() {
        return this.t_price_vat;
    }
    setCurrencyId(currency_id) {
        this.t_currency_id = currency_id;
    }
    getCurrencyId() {
        return this.t_currency_id;
    }
    setFinalPieces(final_pieces) {
        this.t_final_pieces = final_pieces;
    }
    getFinalPieces() {
        return this.t_final_pieces;
    }
    setIconFile(icon_file) {
        this.t_icon_file = icon_file;
    }
    getIconFile() {
        return this.t_icon_file;
    }
}

 class UnitMessenger extends Messenger {
    setName(name) {
        this.t_name = name;
    }
    getName() {
        return this.t_name;
    }
}

 class CategoryMessenger extends Messenger {
    setName(name) {
        this.t_name = name;
    }
    getName() {
        return this.t_name;
    }
}

 class VariantParameterMessenger extends Messenger {
    setName(name) {
        this.t_name = name;
    }
    getName() {
        return this.t_name;
    }
    setCategoryId(category_id) {
        this.t_category_id = category_id;
    }
    getCategoryId() {
        return this.t_category_id;
    }
}

 class VariantParameterToProductMessenger extends Messenger {
    setPriceDifference(price_difference) {
        this.t_price_difference = price_difference;
    }
    getPriceDifference() {
        return this.t_price_difference;
    }
    setChildCategoryId(child_category_id) {
        this.t_child_category_id = child_category_id;
    }
    getChildCategoryId() {
        return this.t_child_category_id;
    }
    setValue(value) {
        this.r_value = value;
    }
    getValue() {
        return this.r_value;
    }
}

 class UserMessenger extends Messenger {
    setEmail(email) {
        this.t_email = email;
    }
    getEmail() {
        return this.t_email;
    }
    setCompanyName(company_name) {
        this.t_company_name = company_name;
    }
    getCompanyName() {
        return this.t_company_name;
    }
    setIc(ic) {
        this.t_ic = ic;
    }
    getIc() {
        return this.t_ic;
    }
    setDic(dic) {
        this.t_dic = dic;
    }
    getDic() {
        return this.t_dic;
    }
    setVat(vat) {
        this.t_vat = vat;
    }
    getVat() {
        return this.t_vat;
    }
    setInvoiceAddressId(invoice_address_id) {
        this.t_invoice_address_id = invoice_address_id;
    }
    getInvoiceAddressId() {
        return this.t_invoice_address_id;
    }
    setDeliveryAddressId(delivery_address_id) {
        this.t_delivery_address_id = delivery_address_id;
    }
    getDeliveryAddressId() {
        return this.t_delivery_address_id;
    }
    setMainContact(main_contact) {
        this.t_main_contact = main_contact;
    }
    getMainContact() {
        return this.t_main_contact;
    }
    setBuyOnCompany(buy_on_company) {
        this.r_buy_on_company = buy_on_company;
    }
    getBuyOnCompany() {
        return this.r_buy_on_company;
    }
}

 class ContactMessenger extends Messenger {
    setEmail(email) {
        this.t_email = email;
    }
    getEmail() {
        return this.t_email;
    }
    setName(name) {
        this.t_name = name;
    }
    getName() {
        return this.t_name;
    }
    setSurname(surname) {
        this.t_surname = surname;
    }
    getSurname() {
        return this.t_surname;
    }
    setTelephone(telephone) {
        this.t_telephone = telephone;
    }
    getTelephone() {
        return this.t_telephone;
    }
}

 class AddressMessenger extends Messenger {
    setStreet(street) {
        this.t_street = street;
    }
    getStreet() {
        return this.t_street;
    }
    setNoHouse(no_house) {
        this.t_no_house = no_house;
    }
    getNoHouse() {
        return this.t_no_house;
    }
    setNoOrientation(no_orientation) {
        this.t_no_orientation = no_orientation;
    }
    getNoOrientation() {
        return this.t_no_orientation;
    }
    setPostcode(postcode) {
        this.t_postcode = postcode;
    }
    getPostcode() {
        return this.t_postcode;
    }
    setCityId(city_id) {
        this.t_city_id = city_id;
    }
    getCityId() {
        return this.t_city_id;
    }
}

 class CityMessenger extends Messenger {
    setName(name) {
        this.t_name = name;
    }
    getName() {
        return this.t_name;
    }
}

 class VariantParametersGroupMessenger extends Messenger {
    constructor() {
        super(...arguments);
        this.t_file_id = null;
        this.t_orig_product_id = null;
        this.t_is_visible_in_card = null;
        this.r_variant_parameter_messengers = null;
    }
    setFileId(file_id) {
        this.t_file_id = file_id;
    }
    getFileId() {
        return this.t_file_id;
    }
    setOrigProductId(orig_product_id) {
        this.t_orig_product_id = orig_product_id;
    }
    getOrigProductId() {
        return this.t_orig_product_id;
    }
    setIsVisibleInCard(is_visible_in_card) {
        this.t_is_visible_in_card = is_visible_in_card;
    }
    getIsVisibleInCard() {
        return this.t_is_visible_in_card;
    }
    setVariantParameterMessengers(variant_parameter_messengers) {
        this.r_variant_parameter_messengers = variant_parameter_messengers;
    }
    getVariantParameterMessengers() {
        return this.r_variant_parameter_messengers;
    }
}

 class VariantParametersGroupController {
    constructor() {
        this.m_variant_parameters_group_messengers = [];
    }
    findAllActiveVariants() {
        let elements = HtmlHelper.getAllOfClass("variant_parameter_value");
        if (elements === null) {
            return;
        }
        let active_variants_ids = [];
        let i = 0;
        let i_max = elements.length;
        while (i < i_max) {
            let element = elements[i];
            if (element instanceof HTMLInputElement) {
                if (element.checked === true) {
                    active_variants_ids.push(parseInt(element.dataset.variantId));
                }
            }
            i++;
        }
        return active_variants_ids;
    }
    processMedia() {
        let active_variants_ids = this.findAllActiveVariants();
        let i = 0;
        let i_max = this.getMessengers().length;
        while (i < i_max) {
            let messenger = this.getMessengers()[i];
            let variant_parameter_messengers = messenger.getVariantParameterMessengers();
            if (variant_parameter_messengers === null) {
                i++;
                continue;
            }
            let ii = 0;
            let ii_max = Object.keys(variant_parameter_messengers).length;
            let all_are_selected = true;
            while (ii < ii_max) {
                let key = active_variants_ids.indexOf(variant_parameter_messengers[ii].getId());
                if (key === -1) {
                    all_are_selected = false;
                }
                ii++;
            }
            if (all_are_selected === true) {
                let media_item_html_id = "preview_media_item_" + messenger.getFileId().getId();
                let media_element = HtmlHelper.getElement(media_item_html_id);
                if (media_element === null) {
                    i++;
                    continue;
                }
                if (media_element !== null) {
                    media_element.click();
                }
                break;
            }
            i++;
        }
    }
    addMessenger(messenger) {
        this.m_variant_parameters_group_messengers.push(messenger);
    }
    getMessengers() {
        return this.m_variant_parameters_group_messengers;
    }
    init() {
        let elements = HtmlHelper.getAllOfClass("variant_parameter_value");
        if (elements === null) {
            return;
        }
        let i = 0;
        let i_max = elements.length;
        while (i < i_max) {
            let element = elements[i];
            if (element instanceof HTMLElement) {
                element.addEventListener("click", this.processMedia.bind(this));
            }
            i++;
        }
    }
}


 class WebMediaController {
    constructor() {
        this.swipe_in_progress = false;
        this.component_element = HtmlHelper.getFirstOfClass("component_media_files");
        this.media_view_element = HtmlHelper.getFirstOfClassInParent("media_view", this.component_element);
        this.media_view_items_wrapper = HtmlHelper.getFirstOfClassInParent("media_view_items_wrapper", this.component_element);
        this.view_media_items = HtmlHelper.getAllOfClass("view_media_item", this.media_view_element);
        this.media_previews_element = HtmlHelper.getFirstOfClassInParent("media_previews", this.component_element);
        this.media_previews_wrapper_element = HtmlHelper.getFirstOfClassInParent("media_previews_wrapper", this.component_element);
        this.preview_media_items = HtmlHelper.getAllOfClass("preview_media_item", this.media_previews_wrapper_element);
        if (this.preview_media_items !== null) {
            let i = 0;
            let i_max = this.preview_media_items.length;
            while (i < i_max) {
                this.preview_media_items[i].addEventListener("click", this.showViewElement.bind(this, this.preview_media_items[i]));
                i++;
            }
        }
        if (this.view_media_items !== null) {
            let first_media = this.view_media_items[0];
            if (first_media instanceof HTMLElement) {
                this.setActiveMediaElement(first_media);
            }
        }
        this.media_view_element.addEventListener('touchstart', this.processTouchStart.bind(this));
        this.media_view_element.addEventListener('touchmove', this.processTouchMove.bind(this));
        this.media_view_element.addEventListener('touchend', this.processTouchEnd.bind(this));
        HtmlHelper.getFirstOfClass("media_view_next").addEventListener("click", this.showNextElement.bind(this));
        HtmlHelper.getFirstOfClass("media_view_previous").addEventListener("click", this.showPreviousElement.bind(this));
        this.initPreviews();
    }
    setActiveMediaElement(element) {
        this.active_media_element = element;
        this.processNewActiveVideo();
        let elements = element.getElementsByTagName("img");
        if (elements === null) {
            return;
        }
        let media_element;
        if (elements[0] instanceof HTMLImageElement) {
            media_element = elements[0];
        }
        else {
            return;
        }
        if (media_element.src === element.dataset.fileUrl) {
            return;
        }
        let image = new Image();
        image.src = element.dataset.fileUrl;
        image.onload = function () {
            media_element.loading = "lazy";
            media_element.src = image.src;
            console.log('Image loaded and updated:' + media_element.src);
            let web_media_dialog_view = HtmlHelper.getFirstOfClass("web_media_dialog_view");
            if (web_media_dialog_view !== null) {
                let elements = web_media_dialog_view.getElementsByTagName("img");
                let media_element = elements[0];
                if (media_element instanceof HTMLImageElement) {
                    media_element.src = image.src;
                }
            }
        };
    }
    processChangeMedia(view_item_element) {
        if (view_item_element instanceof HTMLElement) {
            this.processPreviousActiveVideo();
            this.media_view_items_wrapper.style.left = ((Number(view_item_element.dataset.i) - 1) * -view_item_element.offsetWidth) + "px";
            this.recalcImageCounter(view_item_element.dataset.i);
            this.setActiveMediaElement(view_item_element);
            let web_media_dialog_view = HtmlHelper.getFirstOfClass("web_media_dialog_view");
            if (web_media_dialog_view !== null) {
                web_media_dialog_view.innerHTML = this.active_media_element.innerHTML;
            }
        }
    }
    showViewElement(element) {
        let element_view_id = "view_media_item_" + element.dataset.id;
        let view_item_element = HtmlHelper.getElement(element_view_id);
        this.processChangeMedia(view_item_element);
    }
    showNextElement() {
        let view_item_element = this.active_media_element.nextElementSibling;
        this.processChangeMedia(view_item_element);
    }
    showPreviousElement() {
        let view_item_element = this.active_media_element.previousElementSibling;
        this.processChangeMedia(view_item_element);
    }
    processTouchStart(event) {
        if (this.swipe_in_progress === true) {
            return;
        }
        this.initial_x = event.touches[0].clientX;
        this.initial_y = event.touches[0].clientY;
    }
    processTouchMove(event) {
        if (this.swipe_in_progress === true) {
            return;
        }
        let end_x = event.changedTouches[0].clientX;
        let diff_x = this.initial_x - end_x;
        let end_y = event.changedTouches[0].clientY;
        let diff_y = this.initial_y - end_y;
        if (Math.abs(diff_y) > Math.abs(diff_x)) {
            return;
        }
        if (Math.abs(diff_x) > 25) {
            if (event.cancelable) {
                this.swipe_in_progress = true;
                event.preventDefault();
            }
        }
    }
    processTouchEnd(event) {
        if (this.swipe_in_progress === false) {
            return;
        }
        let end_x = event.changedTouches[0].clientX;
        let diff_x = this.initial_x - end_x;
        let end_y = event.changedTouches[0].clientY;
        let diff_y = this.initial_y - end_y;
        if (Math.abs(diff_y) > Math.abs(diff_x)) {
            return;
        }
        if (Math.abs(diff_x) > 50) {
            if (diff_x > 0) {
                this.showNextElement();
                this.swipe_in_progress = false;
            }
            else {
                this.showPreviousElement();
                this.swipe_in_progress = false;
            }
        }
    }
    recalcImageCounter(new_num) {
        let media_preview_counter_current = HtmlHelper.getFirstOfClass('media_view_counter_current');
        if (media_preview_counter_current === null) {
            return;
        }
        media_preview_counter_current.innerHTML = String(new_num);
    }
    recalcVisibilePreviews() {
        if (this.preview_media_items === null) {
            return 0;
        }
        let i = 0;
        let i_max = this.preview_media_items.length;
        let visible_i = 0;
        while (i < i_max) {
            let parent_bottom = this.preview_media_items[i].parentElement.getBoundingClientRect().bottom;
            if (this.preview_media_items[i].getBoundingClientRect().top < parent_bottom) {
                visible_i++;
            }
            i++;
        }
        return i_max - visible_i;
    }
    initPreviews() {
        let num_of_non_visible_previews = this.recalcVisibilePreviews();
        let show_all_button = HtmlHelper.getFirstOfClass("show_all_button");
        if (num_of_non_visible_previews > 1) {
            HtmlHelper.getFirstOfClassInParent("show_all_count", show_all_button).innerHTML = String(num_of_non_visible_previews);
            show_all_button.addEventListener("click", this.showAllPreviews.bind(this));
        }
        else {
            show_all_button.classList.add("hidden");
        }
    }
    showAllPreviews() {
        let show_all_button = HtmlHelper.getFirstOfClass("show_all_button");
        show_all_button.classList.add("hidden");
        this.media_previews_element.classList.remove("show_one_row");
    }
    processPreviousActiveVideo() {
        let video_elements = this.active_media_element.getElementsByTagName("video");
        if (video_elements[0] !== undefined) {
            video_elements[0].pause();
        }
    }
    processNewActiveVideo() {
        let video_elements = this.active_media_element.getElementsByTagName("video");
        if (video_elements[0] !== undefined) {
            if (video_elements[0].loop === true) {
                video_elements[0].play();
            }
        }
    }
    openDialogWindow() {
        DialogHelper.open('web_media_dialog');
        let web_media_dialog_view = HtmlHelper.getFirstOfClass("web_media_dialog_view");
        web_media_dialog_view.innerHTML = this.active_media_element.innerHTML;
        this.processPreviousActiveVideo();
        HtmlHelper.getFirstOfClass("dialog_media_view_next_wrapper").addEventListener("click", this.showNextElement.bind(this));
        HtmlHelper.getFirstOfClass("dialog_media_view_previous_wrapper").addEventListener("click", this.showPreviousElement.bind(this));
        let dialog_window = HtmlHelper.getElement("dialog_window");
        dialog_window.addEventListener('touchstart', this.processTouchStart.bind(this));
        dialog_window.addEventListener('touchmove', this.processTouchMove.bind(this));
        dialog_window.addEventListener('touchend', this.processTouchEnd.bind(this));
    }
}








 class Product extends Page {
    constructor() {
        super();
        this.m_variant_parameters_controller = new VariantParametersController(this);
        this.m_variant_parameters_group_controller = new VariantParametersGroupController();
    }
    initDom() {
        this.m_web_media_controller = new WebMediaController();
        this.m_variant_parameters_group_controller.init();
        this.getVariantParametersController().initSelectedVariantParameters();
    }
    init() {
        this.recalcPrices();
        this.p_cart_button_controller.getCartButtonDataAction();
    }
    initCartButtonController(cart_button_type, cart_button_id, order_pieces) {
        this.p_cart_button_controller = new CartButtonController(cart_button_type, cart_button_id, order_pieces);
    }
    initOrderFormApiController() {
        this.p_order_form_api_controller = new OrderFormApiController(this, this.p_cart_button_controller);
    }
    changeHeaderValueTextForSelector(select) {
        let header_text_element = document.querySelector('.variant_parameter_header[data-category-id="' + select.dataset.categoryId + '"] .header_value_text');
        header_text_element.textContent = select.options[select.selectedIndex].dataset.name;
        this.recalcPrices();
    }
    changeHeaderValueTextForInput(input) {
        let header_text_element = document.querySelector('.variant_parameter_header[data-category-id="' + input.dataset.categoryId + '"] .header_value_text');
        header_text_element.textContent = input.value;
        this.recalcPrices();
    }
    recalcPrices() {
        let product_price_vat_element = null;
        let product_price_element = null;
        let static_components = document.getElementsByClassName('static_components');
        if (static_components.length) {
            let product_price_vats = static_components[0].getElementsByClassName('product-price');
            if (product_price_vats.length) {
                product_price_vat_element = product_price_vats[0];
            }
            let product_prices = static_components[0].getElementsByClassName('product-price_without_vat-price');
            if (product_prices.length) {
                product_price_element = product_prices[0];
            }
        }
        if (product_price_vat_element === null) {
            return;
        }
        if (!(product_price_vat_element instanceof HTMLElement)) {
            return;
        }
        let price_vat = parseFloat(product_price_vat_element.dataset.priceVat);
        let vat = parseFloat(product_price_vat_element.dataset.vat);
        let currency_name = product_price_vat_element.dataset.currencyName;
        let variant_parameters = document.getElementsByClassName('variant_parameter_value');
        let loops = variant_parameters.length;
        let variant_parameter;
        let price_difference_dataset;
        for (let i = 0; i < loops; i++) {
            variant_parameter = variant_parameters[i];
            if (!(variant_parameter instanceof HTMLElement)) {
                continue;
            }
            switch (Number(variant_parameter.dataset.type)) {
                case 1:
                    if (!(variant_parameter instanceof HTMLInputElement)) {
                        continue;
                    }
                    if (!variant_parameter.checked) {
                        continue;
                    }
                    price_difference_dataset = variant_parameter.dataset;
                    break;
                case 2:
                    if (!(variant_parameter instanceof HTMLSelectElement)) {
                        continue;
                    }
                    price_difference_dataset = variant_parameter.options[variant_parameter.selectedIndex].dataset;
                    break;
                case 3:
                    if (!(variant_parameter instanceof HTMLInputElement)) {
                        continue;
                    }
                    if (variant_parameter.value == "") {
                        continue;
                    }
                    price_difference_dataset = variant_parameter.dataset;
                    break;
            }
            price_vat += parseFloat(price_difference_dataset.priceDifference);
        }
        let price = price_vat / (100.0 + vat) * 100.0;
        product_price_vat_element.textContent = PriceHelper.formatPrice(price_vat, currency_name);
        product_price_vat_element.dataset.priceReal = price_vat.toString();
        if (product_price_element !== null) {
            product_price_element.textContent = PriceHelper.formatPrice(price, currency_name);
        }
    }
    initSearchAutoCompleteController(autocomplete_html_id, use_autocomplete, use_submit_action_product, target_url_name) {
        return new SearchAutoCompleteController(this, autocomplete_html_id, "find_products", use_autocomplete, use_submit_action_product, target_url_name);
    }
    getVariantParametersController() {
        return this.m_variant_parameters_controller;
    }
    getVariantParametersGroupController() {
        return this.m_variant_parameters_group_controller;
    }
    getWebMediaController() {
        return this.m_web_media_controller;
    }
}