"use strict";

(function () {
    /**** POLYFILLS ****/

    if (!Element.prototype.matches) {
        Element.prototype.matches = Element.prototype.msMatchesSelector ||
            Element.prototype.webkitMatchesSelector;
    }

    if (typeof Object.assign != "function" && Object.defineProperty) {
        Object.defineProperty(Object,
            "assign", {
                value: function assign(target, varArgs) {

                    if (target == null) {
                        throw new TypeError("Cannot convert undefined or null to object");
                    }

                    var to = Object(target);

                    for (var index = 1; index < arguments.length; index++) {
                        var nextSource = arguments[index];

                        if (nextSource != null) {
                            for (var nextKey in nextSource) {
                                if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
                                    to[nextKey] = nextSource[nextKey];
                                }
                            }
                        }
                    }
                    return to;
                },
                writable: true,
                configurable: true
            });
    }
})();

(function (EP) {
    var Utils = EP.Utils || (EP.Utils = {});

    Utils.getElementText = function (el) {
        return el.innerText || el.textContent;
    };

    Utils.getCookie = function (name) {
        var match = document.cookie.match(new RegExp("(^| )" + name + "=([^;]+)"));
        return match ? match[2] : null;
    };

    Utils.isArray = function (val) {
        if (!val) return false;
        if (Array.isArray) return Array.isArray(val);
        return Object.prototype.toString.call(val) === "[object Array]";
    };

})(window.EP || (window.EP = {}));

(function (EP) {
    var Analytics = EP.Analytics || (EP.Analytics = {});
    var API_KEY = "ff1391a588ad830bb306872e4ada5fad";
    var DATA_KEY = '[data-amplitude]';
    var DATA_AMPLITUDE_KEY = "amplitude";
    var UDT_state = "#UdtValueHolder#";
    var UDT_was_set = "#FlagUdtSet#";
    var rulesMap = {};
    var isInitialized = false;
    var isPageLoaded = false;

    var defaultRuleConfig = {
        capture: false
    };

    var commonTabsRule = {
        type: 'Tab - clicked',
        event: 'click',
        handler: function (ctx) {
            ctx.track({
                name: EP.Utils.getElementText(ctx.e.target)
            });
        }
    };
    var commonLinksRule = {
        event: 'click'
    };

    var commonSubTabsRule = {
        type: 'Sub Tabs - clicked',
        event: 'click',
        handler: function (ctx) {
            ctx.track({
                name: ctx.arg
            });
        },
        selector: 'img'
    };

    function initialize() {
        if (isInitialized) throw new Error("is already initialized");
        isInitialized = true;

        var userData = getUserData();
        amplitude.getInstance().init(API_KEY, userData ? userData.uid : null);

        document.addEventListener("DOMContentLoaded",
            function () {
                isPageLoaded = true;
                bindListeners();
            });
    }

    /**
     * @param {string} uid
     * @param {RuleDescriptor} rule
     */
    function addRule(uid, rule) {
        if (rulesMap[uid])
            return;

        rulesMap[uid] = rule;
        if (isPageLoaded) {
            bindListenerAfterLoad(uid, rule);
        }
    }

    function addRuleForSubTab(uid, tabName) {
        addRule(uid, ruleTab(tabName));
    }

    function addRuleForTab(uid) {
        var rule = Object.assign({}, defaultRuleConfig, commonTabsRule);
        addRule(uid, rule);
    }

    function addRuleForLink(uid, linkType, selector) {
        var rule = Object.assign({}, defaultRuleConfig, commonLinksRule);
        rule.type = linkType;
        if (selector)
            rule.selector = selector;
        addRule(uid, rule);
    }

    function addRuleForDropdown(uid, name) {
        var rule = {
            event: 'change',
            type: name,
            handler: function(ctx) {
                var options = ctx.e.target.options;
                ctx.track({
                    value: options[options.selectedIndex].outerText
                });
            }
        };

        addRule(uid, rule);
    }

    function isEditMode(id) {
        var urlParams = new URLSearchParams(window.location.search);
        return urlParams.get(id) != null;
    }

    function getRuleForSubmitButton(parameters) {
        var rule = {
            event: 'click',
            type: parameters.editMode ? parameters.ruleTypeEditMessage : parameters.ruleTypeAddMessage,
            handler: function (ctx) {
                parameters.getLmsPlatform.bind(parameters);
                var lmsPlatform = parameters.getLmsPlatform();
                var customerId = document.querySelector('[id*="_siteId"]').outerText.match(/\(([^)]+)\)/)[1];

                ctx.track({
                    LMS_Platform: lmsPlatform,
                    CustomerID: customerId,
                    Name: parameters.editMode ? parameters.ruleNameEditMessage : parameters.ruleAddEditMessage,
                });
            }
        }
        return rule;
    }

    function ruleTab(name) {
        var rule = Object.assign({}, defaultRuleConfig, commonSubTabsRule);
        rule.arg = name;
        return rule;
    }

    function trackEvent(type, properties) {
        if (!type) throw new Error("type");
        properties = properties || {};
        properties['event_type'] = type;
        amplitude.getInstance().logEvent(type, Object.assign({}, EP.Analytics.globalParams, properties));
    }

    function createRuleHandlerContext(rule, type, event) {
        var ctx = {
            e: event,
            type: type,
            track: trackEvent.bind(null, type)
        };

        if (rule.arg) {
            ctx.arg = rule.arg;
        }

        return ctx;
    }

    function getUserData() {
        if (UDT_was_set === "#true") {
            return JSON.parse(atob(UDT_state));
        }
        return null;
    }

    function bindListeners() {
        var controlToLogs = document.querySelectorAll(DATA_KEY);
        for (var i = 0; i < controlToLogs.length; i++) {
            var elem = controlToLogs[i];
            var uid = elem.dataset[DATA_AMPLITUDE_KEY];
            var rule = findRuleByUID(uid);
            if (rule) {
                if (rule.selector) {
                    var elements = elem.querySelectorAll(rule.selector);
                    for (var j = 0; j < elements.length; j++)
                        elements[j].addEventListener(rule.event, trackRuleOnEvent.bind(this, rule), false);
                }
                else
                    elem.addEventListener(rule.event, trackRuleOnEvent.bind(this, rule), false);
            }
        }
    }

    function bindListenerAfterLoad(uid, rule) {
        var elem = document.querySelector('[data-amplitude=' + uid + ']');
        if (!elem)
            return;

        if (rule.selector) {
            var elements = elem.querySelectorAll(rule.selector);
            for (var j = 0; j < elements.length; j++)
                elements[j].addEventListener(rule.event, trackRuleOnEvent.bind(this, rule), false);
        }
        else
            elem.addEventListener(rule.event, trackRuleOnEvent.bind(this, rule), false);
    }


    function trackRuleOnEvent(rule, e) {
        if (!e.isTrusted) return;
        if (rule.trackOn && !e.target.matches(rule.selector)) return;

        // filter bubbling/capturing events if "trackOn" is not set
        if (!rule.trackOn && e.target !== e.currentTarget) return;

        var type = typeof rule.type === "function" ? rule.type(e) : rule.type;
        if (!type) {
            console.warn("event type is not resolved", e);
            return;
        }

        if (typeof rule.handler === "function") {
            rule.handler(createRuleHandlerContext(rule, type, e));
        } else {
            trackEvent(type);
        }
    }

    function findRuleByUID(uid) {
        return rulesMap[uid];
    }

    Analytics.trackEvent = trackEvent;
    Analytics.addRule = addRule;
    Analytics.addRuleForSubTab = addRuleForSubTab;
    Analytics.addRuleForTab = addRuleForTab;
    Analytics.addRuleForLink = addRuleForLink;
    Analytics.addRuleForDropdown = addRuleForDropdown;
    Analytics.getRuleForSubmitButton = getRuleForSubmitButton;
    Analytics.isEditMode = isEditMode;

    initialize();

})(window.EP || (window.EP = {}));