/*******************************************************************************

    ηMatrix - a browser extension to black/white list requests.
    Copyright (C) 2014-2019 Raymond Hill
    Copyright (C) 2019-2020 Alessio Vanni

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see {http://www.gnu.org/licenses/}.

    Home: https://libregit.spks.xyz/heckyel/ematrix
    uMatrix Home: https://github.com/gorhill/uMatrix
*/

'use strict';

// Default handler
(function () {
    Cu.import('chrome://ematrix/content/lib/Tools.jsm');

    let ηm = ηMatrix;

    // Default is for commonly used message.
    function onMessage(request, sender, callback) {
        // Async
        switch (request.what) {
        case 'getAssetContent':
            ηm.assets.get(request.url, {
                dontCache: true,
            }, callback);
            return;
        case 'selectHostsFiles':
            ηm.selectHostsFiles(request, callback);
            return;
        default:
            break;
        }

        // Sync
        let response;

        switch (request.what) {
        case 'forceReloadTab':
            ηm.forceReload(request.tabId, request.bypassCache);
            break;
        case 'forceUpdateAssets':
            ηm.scheduleAssetUpdater(0);
            ηm.assets.updateStart({
                delay: 2000,
            });
            break;
        case 'getUserSettings':
            response = {
                userSettings: ηm.userSettings,
                matrixSwitches: {
                    'https-strict': ηm.pMatrix.evaluateSwitch('https-strict', '*') === 1,
                    'referrer-spoof': ηm.pMatrix.evaluateSwitch('referrer-spoof', '*') === 1,
                    'noscript-spoof': ηm.pMatrix.evaluateSwitch('noscript-spoof', '*') === 1,
                },
            };
            break;
        case 'gotoExtensionURL':
            Tools.gotoExtensionURL({
                api: vAPI,
                details: request,
                matrix: ηm,
            });
            break;
        case 'gotoURL':
            Tools.gotoURL({
                api: vAPI,
                details: request,
            });
            break;
        case 'mustBlock':
            response = ηm.mustBlock(request.scope,
                                    request.hostname,request.type);
            break;
        case 'readRawSettings':
            response = ηm.stringFromRawSettings();
            break;
        case 'reloadHostsFiles':
            ηm.reloadHostsFiles();
            break;
        case 'setMatrixSwitch':
            ηm.tMatrix.setSwitch(request.switchName, '*', request.state);
            if (ηm.pMatrix.setSwitch(request.switchName, '*', request.state)) {
                ηm.saveMatrix();
            }
            break;
        case 'userSettings':
            if (request.hasOwnProperty('value') === false) {
                request.value = undefined;
            }
            response = ηm.changeUserSettings(request.name, request.value);
            break;
        case 'writeRawSettings':
            ηm.rawSettingsFromString(request.content);
            break;
        default:
            return vAPI.messaging.UNHANDLED;
        }
        callback(response);
    }

    vAPI.messaging.setup(onMessage);
})();

(function () {
    // popup.js

    let ηm = ηMatrix;

    // Constructor is faster than object literal
    // ηMatrix: really? I'll take your word for it...
    let RowSnapshot = function(srcHostname, desHostname, desDomain) {
        this.domain = desDomain;
        this.temporary = ηm.tMatrix.evaluateRowZXY(srcHostname, desHostname);
        this.permanent = ηm.pMatrix.evaluateRowZXY(srcHostname, desHostname);
        this.counts = RowSnapshot.counts.slice();
        this.totals = RowSnapshot.counts.slice();
    };

    RowSnapshot.counts = (function () {
        let aa = [];
        let n = ηm.Matrix.columnHeaderIndices.size

        for (let i=0; i<n; ++i) {
            aa[i] = 0;
        }

        return aa;
    })();

    let matrixSnapshot = function (pageStore, details) {
        let ηmuser = ηm.userSettings;
        let headerIndices = ηm.Matrix.columnHeaderIndices;

        let r = {
            appVersion: vAPI.app.version,
            blockedCount: pageStore.requestStats.blocked.all,
            collapseAllDomains: ηmuser.popupCollapseAllDomains,
            collapseBlacklistedDomains: ηmuser.popupCollapseBlacklistedDomains,
            diff: [],
            domain: pageStore.pageDomain,
            has3pReferrer: pageStore.has3pReferrer,
            hasMixedContent: pageStore.hasMixedContent,
            hasNoscriptTags: pageStore.hasNoscriptTags,
            hasWebWorkers: pageStore.hasWebWorkers,
            headerIndices: Array.from(headerIndices),
            hostname: pageStore.pageHostname,
            mtxContentModified: pageStore.mtxContentModifiedTime !== details.mtxContentModifiedTime,
            mtxCountModified: pageStore.mtxCountModifiedTime !== details.mtxCountModifiedTime,
            mtxContentModifiedTime: pageStore.mtxContentModifiedTime,
            mtxCountModifiedTime: pageStore.mtxCountModifiedTime,
            pMatrixModified: ηm.pMatrix.modifiedTime !== details.pMatrixModifiedTime,
            pMatrixModifiedTime: ηm.pMatrix.modifiedTime,
            pSwitches: {},
            rows: {},
            rowCount: 0,
            scope: '*',
            tabId: pageStore.tabId,
            tMatrixModified: ηm.tMatrix.modifiedTime !== details.tMatrixModifiedTime,
            tMatrixModifiedTime: ηm.tMatrix.modifiedTime,
            tSwitches: {},
            url: pageStore.pageUrl,
            userSettings: {
                colorBlindFriendly: ηmuser.colorBlindFriendly,
                displayTextSize: ηmuser.displayTextSize,
                popupScopeLevel: ηmuser.popupScopeLevel
            },
        };

        if (typeof details.scope === 'string') {
            r.scope = details.scope;
        } else if (ηmuser.popupScopeLevel === 'site') {
            r.scope = r.hostname;
        } else if (ηmuser.popupScopeLevel === 'domain') {
            r.scope = r.domain;
        }

        for (let switchName of ηm.Matrix.switchNames) {
            r.tSwitches[switchName] =
                ηm.tMatrix.evaluateSwitchZ(switchName, r.scope);

            r.pSwitches[switchName] =
                ηm.pMatrix.evaluateSwitchZ(switchName, r.scope);
        }

        // These rows always exist
        r.rows['*'] = new RowSnapshot(r.scope, '*', '*');
        r.rows['1st-party'] = new RowSnapshot(r.scope,
                                              '1st-party', '1st-party');
        r.rowCount += 1;

        let anyIndex = headerIndices.get('*');
        for (let entry of pageStore.hostnameTypeCells) {
            let pos = entry[0].indexOf(' ');
            let reqHostname = entry[0].slice(0, pos);
            let reqType = entry[0].slice(pos + 1);

            // rhill 2013-10-23: hostname can be empty if the request
            // is a data url
            // https://github.com/gorhill/httpswitchboard/issues/26
            if (reqHostname === '') {
                reqHostname = pageStore.pageHostname;
            }

            let reqDomain =
                UriTools.domainFromHostname(reqHostname) || reqHostname;

            // We want rows of self and ancestors
            let desHostname = reqHostname;
            for (;;) {
                // If row exists, ancestors exist
                if (r.rows.hasOwnProperty(desHostname) !== false) {
                    break;
                }

                r.rows[desHostname] =
                    new RowSnapshot(r.scope, desHostname, reqDomain);
                r.rowCount += 1;

                if (desHostname === reqDomain) {
                    break;
                }

                pos = desHostname.indexOf('.');
                if (pos === -1) {
                    break;
                }

                desHostname = desHostname.slice(pos + 1);
            }

            let count = entry[1].size;
            let typeIndex = headerIndices.get(reqType);

            let row = r.rows[reqHostname];
            row.counts[typeIndex] += count;
            row.counts[anyIndex] += count;
            row = r.rows[reqDomain];
            row.totals[typeIndex] += count;
            row.totals[anyIndex] += count;
            row = r.rows['*'];
            row.totals[typeIndex] += count;
            row.totals[anyIndex] += count;
        }

        r.diff = ηm.tMatrix.diff(ηm.pMatrix, r.hostname, Object.keys(r.rows));

        return r;
    };

    let matrixSnapshotFromTabId = function (details, callback) {
        let matrixSnapshotIf = function (tabId, details) {
            let pageStore = ηm.pageStoreFromTabId(tabId);
            if (pageStore === null) {
                callback('ENOTFOUND');
                return;
            }

            // First verify whether we must return data or not.
            if (ηm.tMatrix.modifiedTime === details.tMatrixModifiedTime
                && ηm.pMatrix.modifiedTime === details.pMatrixModifiedTime
                && pageStore.mtxContentModifiedTime === details.mtxContentModifiedTime
                && pageStore.mtxCountModifiedTime === details.mtxCountModifiedTime) {
                callback('ENOCHANGE');
                return ;
            }

            callback(matrixSnapshot(pageStore, details));
        };

        // Specific tab id requested?
        if (details.tabId) {
            matrixSnapshotIf(details.tabId, details);
            return;
        }

        // Fall back to currently active tab
        let onTabReady = function (tab) {
            if (tab instanceof Object === false) {
                callback('ENOTFOUND');
                return;
            }

            // Allow examination of behind-the-scene requests
            let tabId =
                tab.url.lastIndexOf(vAPI.getURL('dashboard.html'), 0) !== 0 ?
                tab.id :
                vAPI.noTabId;
            matrixSnapshotIf(tabId, details);
        };

        vAPI.tabs.get(null, onTabReady);
    };

    let onMessage = function (request, sender, callback) {
        // Async
        switch (request.what) {
        case 'matrixSnapshot':
            matrixSnapshotFromTabId(request, callback);
            return;
        default:
            break;
        }

        // Sync
        let response;
        switch (request.what) {
        case 'toggleMatrixSwitch':
            let switchZ = ηm.tMatrix.evaluateSwitchZ(request.switchName,
                                                     request.srcHostname)
            ηm.tMatrix.setSwitchZ(request.switchName,
                                  request.srcHostname,
                                  switchZ === false);
            break;
        case 'blacklistMatrixCell':
            ηm.tMatrix.blacklistCell(request.srcHostname,
                                     request.desHostname,
                                     request.type);
            break;
        case 'whitelistMatrixCell':
            ηm.tMatrix.whitelistCell(request.srcHostname,
                                     request.desHostname,
                                     request.type);
            break;
        case 'graylistMatrixCell':
            ηm.tMatrix.graylistCell(request.srcHostname,
                                    request.desHostname,
                                    request.type);
            break;
        case 'applyDiffToPermanentMatrix': // aka "persist"
            if (ηm.pMatrix.applyDiff(request.diff, ηm.tMatrix)) {
                ηm.saveMatrix();
            }
            break;
        case 'applyDiffToTemporaryMatrix': // aka "revert"
            ηm.tMatrix.applyDiff(request.diff, ηm.pMatrix);
            break;
        case 'revertTemporaryMatrix':
            ηm.tMatrix.assign(ηm.pMatrix);
            break;
        default:
            return vAPI.messaging.UNHANDLED;
        }

        callback(response);
    };

    vAPI.messaging.listen('popup.js', onMessage);
})();

// content scripts
(function () {

    let ηm = ηMatrix;

    let foundInlineCode = function (tabId, pageStore, details, type) {
        if (pageStore === null) {
            return;
        }

        let pageHostname = pageStore.pageHostname;
        let ηmuri = UriTools.set(details.documentURI);
        let frameURL = UriTools.normalizedURI();

        let blocked = details.blocked;
        if (blocked === undefined) {
            blocked = ηm.mustBlock(pageHostname, ηmuri.hostname, type);
        }

        let mapTo = {
            css: 'style',
            script: 'script',
        };

        // https://github.com/gorhill/httpswitchboard/issues/333
        // Look-up here whether inline scripting is blocked for the frame.
        let url = frameURL + '{inline_' + mapTo[type] + '}';
        pageStore.recordRequest(type, url, blocked);
        ηm.logger.writeOne(tabId, 'net', pageHostname, url, type, blocked);
    };

    let contentScriptLocalStorageHandler = function (tabId, originURL) {
        let tabContext = ηm.tabContextManager.lookup(tabId);
        if (tabContext === null) {
            return;
        }

        let blocked = ηm.mustBlock(tabContext.rootHostname,
                                   UriTools.hostnameFromURI(originURL),
                                   'cookie');

        let pageStore = ηm.pageStoreFromTabId(tabId);
        if (pageStore !== null) {
            let requestURL = originURL + '/{localStorage}';
            pageStore.recordRequest('cookie', requestURL, blocked);
            ηm.logger.writeOne(tabId, 'net', tabContext.rootHostname,
                               requestURL, 'cookie', blocked);
        }

        let removeStorage = blocked && ηm.userSettings.deleteLocalStorage;
        if (removeStorage) {
            ηm.localStorageRemovedCounter++;
        }

        return removeStorage;
    };

    // Evaluate many URLs against the matrix.
    let lookupBlockedCollapsibles = function (tabId, requests) {
        if (placeholdersReadTime < ηm.rawSettingsWriteTime) {
            placeholders = undefined;
        }

        if (placeholders === undefined) {
            placeholders = {
                frame: ηm.rawSettings.framePlaceholder,
                image: ηm.rawSettings.imagePlaceholder,
            };
            if (placeholders.frame) {
                placeholders.frameDocument =
                    ηm.rawSettings
                    .framePlaceholderDocument
                    .replace('{{bg}}',
                             ηm.rawSettings.framePlaceholderBackground !== 'default' ?
                             ηm.rawSettings.framePlaceholderBackground :
                             ηm.rawSettings.placeholderBackground);
            }
            if (placeholders.image) {
                placeholders.imageBorder =
                    ηm.rawSettings.imagePlaceholderBorder !== 'default' ?
                    ηm.rawSettings.imagePlaceholderBorder :
                    ηm.rawSettings.placeholderBorder;
                placeholders.imageBackground =
                    ηm.rawSettings.imagePlaceholderBackground !== 'default' ?
                    ηm.rawSettings.imagePlaceholderBackground :
                    ηm.rawSettings.placeholderBackground;
            }
            placeholdersReadTime = Date.now();
        }

        let response = {
            blockedResources: [],
            hash: requests.hash,
            id: requests.id,
            placeholders: placeholders,
        };

        let tabContext = ηm.tabContextManager.lookup(tabId);
        if (tabContext === null) {
            return response;
        }

        let pageStore = ηm.pageStoreFromTabId(tabId);
        if (pageStore !== null) {
            pageStore.lookupBlockedCollapsibles(requests, response);
        }

        return response;
    };

    let placeholders;
    let placeholdersReadTime = 0;

    let onMessage = function (request, sender, callback) {
        // Async
        switch (request.what) {
        default:
            break;
        }

        let tabId = sender && sender.tab ? sender.tab.id || 0 : 0;
        let tabContext = ηm.tabContextManager.lookup(tabId);
        let rootHostname = tabContext && tabContext.rootHostname;
        let pageStore = ηm.pageStoreFromTabId(tabId);

        // Sync
        let response;
        switch (request.what) {
        case 'contentScriptHasLocalStorage':
            response =
                contentScriptLocalStorageHandler(tabId, request.originURL);
            break;
        case 'lookupBlockedCollapsibles':
            response = lookupBlockedCollapsibles(tabId, request);
            break;
        case 'mustRenderNoscriptTags?':
            if (tabContext === null) {
                break;
            }

            response =
                ηm.tMatrix.mustBlock(rootHostname, rootHostname, 'script')
                && ηm.tMatrix.evaluateSwitchZ('noscript-spoof', rootHostname);

            if (pageStore !== null) {
                pageStore.hasNoscriptTags = true;
            }

            // https://github.com/gorhill/uMatrix/issues/225
            // A good place to force an update of the page title, as
            // at this point the DOM has been loaded.
            ηm.updateTitle(tabId);
            break;
        case 'securityPolicyViolation':
            if (request.directive === 'worker-src') {
                let url = UriTools.hostnameFromURI(request.blockedURI) !== '' ?
                    request.blockedURI :
                    request.documentURI;

                if (pageStore !== null) {
                    pageStore.hasWebWorkers = true;
                    pageStore.recordRequest('script', url, request.blocked);
                }

                if (tabContext !== null) {
                    ηm.logger.writeOne(tabId, 'net', rootHostname,
                                       url, 'worker', request.blocked);
                }
            } else if (request.directive === 'script-src') {
                foundInlineCode(tabId, pageStore, request, 'script');
            } else if (request.directive === 'style-src') {
                foundInlineCode(tabId, pageStore, request, 'css');
            }
            break;
        case 'shutdown?':
            if (tabContext !== null) {
                response =
                    ηm.tMatrix.evaluateSwitchZ('matrixb-off', rootHostname);
            }
            break;
        default:
            return vAPI.messaging.UNHANDLED;
        }

        callback(response);
    };

    vAPI.messaging.listen('contentscript.js', onMessage);
})();

// cloud-ui.js
(function () {

    let ηm = ηMatrix;

    let onMessage = function (request, sender, callback) {
        // Async
        switch (request.what) {
        case 'cloudGetOptions':
            vAPI.cloud.getOptions(function (options) {
                options.enabled = ηm.userSettings.cloudStorageEnabled === true;
                callback(options);
            });
            return;
        case 'cloudSetOptions':
            vAPI.cloud.setOptions(request.options, callback);
            return;
        case 'cloudPull':
            return vAPI.cloud.pull(request.datakey, callback);
        case 'cloudPush':
            return vAPI.cloud.push(request.datakey, request.data, callback);
        default:
            break;
        }

        // Sync
        let response;
        switch (request.what) {
            // For when cloud storage is disabled.
        case 'cloudPull':
            // fallthrough
        case 'cloudPush':
            break;
        default:
            return vAPI.messaging.UNHANDLED;
        }

        callback(response);
    };

    vAPI.messaging.listen('cloud-ui.js', onMessage);
})();

// user-rules.js
(function () {

    let ηm = ηMatrix;

    let onMessage = function (request, sender, callback) {
        // Async
        switch (request.what) {
        default:
            break;
        }

        // Sync
        let response;
        switch (request.what) {
        case 'getUserRules':
            response = {
                temporaryRules: ηm.tMatrix.toString(),
                permanentRules: ηm.pMatrix.toString(),
            };
            break;
        case 'setUserRules':
            if (typeof request.temporaryRules === 'string') {
                ηm.tMatrix.fromString(request.temporaryRules);
            }
            if (typeof request.permanentRules === 'string') {
                ηm.pMatrix.fromString(request.permanentRules);
                ηm.saveMatrix();
            }
            response = {
                temporaryRules: ηm.tMatrix.toString(),
                permanentRules: ηm.pMatrix.toString(),
            };
            break;
        default:
            return vAPI.messaging.UNHANDLED;
        }

        callback(response);
    };

    vAPI.messaging.listen('user-rules.js', onMessage);
})();

// hosts-files.js
(function () {

    let ηm = ηMatrix;

    let prepEntries = function (entries) {
        let ηmuri = UriTools;
        let entry;
        for (let k in entries) {
            if (entries.hasOwnProperty(k) === false) {
                continue;
            }

            entry = entries[k];

            if (typeof entry.homeURL === 'string') {
                entry.homeHostname = ηmuri.hostnameFromURI(entry.homeURL);
                entry.homeDomain = ηmuri.domainFromHostname(entry.homeHostname);
            }
        }
    };

    let getLists = function (callback) {
        let r = {
            autoUpdate: ηm.userSettings.autoUpdate,
            available: null,
            cache: null,
            current: ηm.liveHostsFiles,
            blockedHostnameCount: ηm.ubiquitousBlacklist.count,
        };

        let onMetadataReady = function (entries) {
            r.cache = entries;
            prepEntries(r.cache);
            callback(r);
        };

        let onAvailableHostsFilesReady = function (lists) {
            r.available = lists;
            prepEntries(r.available);
            ηm.assets.metadata(onMetadataReady);
        };

        ηm.getAvailableHostsFiles(onAvailableHostsFilesReady);
    };

    let onMessage = function (request, sender, callback) {
        let ηm = ηMatrix;

        // Async
        switch (request.what) {
        case 'getLists':
            return getLists(callback);
        default:
            break;
        }

        // Sync
        let response;
        switch (request.what) {
        case 'purgeCache':
            ηm.assets.purge(request.assetKey);
            ηm.assets.remove('compiled/' + request.assetKey);
            break;
        case 'purgeAllCaches':
            if (request.hard) {
                ηm.assets.remove(/./);
            } else {
                ηm.assets.purge(/./, 'public_suffix_list.dat');
            }
            break;
        default:
            return vAPI.messaging.UNHANDLED;
        }

        callback(response);
    };

    vAPI.messaging.listen('hosts-files.js', onMessage);
})();

// about.js
(function () {

    let ηm = ηMatrix;

    let restoreUserData = function (userData) {
        let countdown = 4;
        let onCountdown = function () {
            countdown -= 1;
            if (countdown === 0) {
                vAPI.app.restart();
            }
        };

        let onAllRemoved = function () {
            vAPI.storage.set(userData.settings, onCountdown);
            vAPI.storage.set({
                userMatrix: userData.rules,
            }, onCountdown);
            vAPI.storage.set({
                liveHostsFiles: userData.hostsFiles,
            }, onCountdown);

            if (userData.rawSettings instanceof Object) {
                ηMatrix.saveRawSettings(userData.rawSettings, onCountdown);
            }
        };

        // If we are going to restore all, might as well wipe out
        // clean local storage
        ηm.XAL.keyvalRemoveAll(onAllRemoved);
    };

    let resetUserData = function () {
        let onAllRemoved = function () {
            vAPI.app.restart();
        };
        ηm.XAL.keyvalRemoveAll(onAllRemoved);
    };

    let onMessage = function (request, sender, callback) {
        // Async
        switch (request.what) {
        default:
            break;
        }

        // Sync
        let response;
        switch (request.what) {
        case 'getAllUserData':
            response = {
                app: vAPI.app.name,
                version: vAPI.app.version,
                when: Date.now(),
                settings: ηm.userSettings,
                rules: ηm.pMatrix.toString(),
                hostsFiles: ηm.liveHostsFiles,
                rawSettings: ηm.rawSettings,
            };
            break;
        case 'getSomeStats':
            response = {
                version: vAPI.app.version,
                storageUsed: ηm.storageUsed
            };
            break;
        case 'restoreAllUserData':
            restoreUserData(request.userData);
            break;
        case 'resetAllUserData':
            resetUserData();
            break;
        default:
            return vAPI.messaging.UNHANDLED;
        }

        callback(response);
    };

    vAPI.messaging.listen('about.js', onMessage);
})();

// logger-ui.js
(function () {

    let ηm = ηMatrix;
    let loggerURL = vAPI.getURL('logger-ui.html');

    let onMessage = function (request, sender, callback) {
        // Async
        switch (request.what) {
        default:
            break;
        }

        // Sync
        let response;
        switch (request.what) {
        case 'readMany':
            if (ηm.logger.ownerId !== undefined
                && request.ownerId !== ηm.logger.ownerId) {
                response = {
                    unavailable: true,
                };
                break;
            }
            let tabIds = {};
            for (let tabId in ηm.pageStores) {
                let pageStore = ηm.pageStoreFromTabId(tabId);

                if (pageStore === null) {
                    continue;
                }
                if (pageStore.rawUrl.startsWith(loggerURL)) {
                    continue;
                }

                tabIds[tabId] = pageStore.title || pageStore.rawUrl;
            }

            response = {
                colorBlind: false,
                entries: ηm.logger.readAll(request.ownerId),
                maxLoggedRequests: ηm.userSettings.maxLoggedRequests,
                noTabId: vAPI.noTabId,
                tabIds: tabIds,
                tabIdsToken: ηm.pageStoresToken,
            };
            break;
        case 'releaseView':
            if (request.ownerId === ηm.logger.ownerId) {
                ηm.logger.ownerId = undefined;
            }
            break;
        default:
            return vAPI.messaging.UNHANDLED;
        }

        callback(response);
    };

    vAPI.messaging.listen('logger-ui.js', onMessage);
})();