/**
 **********************************************************************
 * Tranquility Reader - A Firefox Webextension that cleans up
 * cluttered web pages
 **********************************************************************

   Copyright (c) 2012-2022 Arun Kunchithapatham

    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/>.

   Contributors:
   Arun Kunchithapatham - Initial Contribution
 ***********************************************************************
 *
 */

/*
 * Process the messages appropriately
 * 
 */

'use strict';
var browser = browser || chrome;
var currentURL = null;
var dfsIndex = 1;
var osVersion = browser.runtime.PlatformOs;
var zoomValue = 1.0;
var currentFontSize = "20px";
const DEBUG = true;
var print = DEBUG ? alert : console.log

function tranquilize(request, sender, sendResponse) {

    if (request.tranquility_action === 'Run') {
        print("Called to run Tranquility at: " + new Date());
        RunOnLoad();
        return Promise.resolve({response: "Completed Running Tranquility"});
    }
    else if (request.tranquility_action === 'RunAndSave') {
        print("Called to run and Save Tranquility at: " + new Date());
        RunAndSaveOnLoad();
        return Promise.resolve({response: "Completed Saving Content Offline"});
    }
    else if (request.tranquility_action == 'RunOnSelection') {
        print("Called to run Tranquility at: " + new Date());
        RunOnSelection();
        return Promise.resolve({response: "Completed Running Tranquility on Selection"});
    }
    else if (request.tranquility_action === 'PopulateOfflineList') {
        print("Receive message to display offline files list");
        displayOfflinePages(request.offline_data);
    }
    else if (request.tranquility_action === 'DisplayOfflineDocument') {
        print("Received offline document from database");
        displayDocFromDB(request.cached_doc, request.url);
    }
    else if (request.tranquility_action === 'DeleteOfflineDocumentLink') {
        delDocFromDB(request.url);
    }
    else if (request.tranquility_action === 'CreateExportLink') {
        print("Received message to export offline links");
        displayExportLink(request.offline_data);
    }
    else if (request.tranquility_action === 'ImportOfflinePages') {
        displayImportPage();
        return Promise.resolve({response: "Created Page for Import Prompt"});
    }
    else if (request.tranquility_action === 'AddAnnotation') {
        addAnnotation();
    }
    else if (request.tranquility_action === 'UpdateTranquilityPreferences') {
        if (document.getElementsByClassName("tranquility_container").length > 0) {
            applyAllTranquilityPreferences();
            return Promise.resolve({response: "Updated Tranquility Preferences"});
        }
        else {
            return Promise.resolve({response: "Tab does not contain Tranquility Reader elements"});
        }
    }
    else if (request.tranquility_action == 'Status') {
        return Promise.resolve({response: "Tranquility Has Already Run"});
    }
    else if (request.tranquility_action == 'UpdateZoomValue') {
        updateZoomValue(request.zoomValue);
        return Promise.resolve({response: "Updated Zoom Value"});
    }
    else if (request.tranquility_action == 'ExecutePostPDFPrintActions') {

        // Reset page to default column-num value post printing
        // Then reapply the image display preferences
        applyNumColumnsPreferences('defaultMode');
        applyImageDisplayPreferences();

        return Promise.resolve({response: "Executed Post PDF Print Actions"});
    }
    else if (request.tranquility_action == 'None') {
        return Promise.resolve({response: "Receive Do Nothing Message"});
    }
    else {
        print("Message not implemented: " + request.tranquility_action);
    }
}

function RunOnLoad() {

    requestZoomValue();

    currentURL = location.toString();
    // If we have already run tranquility, then just toggle back to the original webpage (un-tranquilize the page)
    if (document.body.getElementsByClassName("tranquility").length > 0) {
        // If this is an offline link, we need to get the data-active-link of the tranquility_offline_links_btn
        print("Document already in tranquility mode. Reverting to original page...");
        let btn = document.getElementById('tranquility_offline_links_btn');
        let url = null;
        if(btn.getAttribute('data-active-link')) {
            print("Found data active link...");
            url = btn.getAttribute('data-active-link');
        }
        else {
            url = currentURL;
        }
        print("url: " + url);

        // Handle corner case when the url has a "#" tag
        // this can prevent the window.location.assign from working!
        //
        window.location.assign(url.split("#")[0]);
    }
    // If tranquility has not been run, then "tranquilize" the document
    else {
        // Stop loading the document if it has not completed loading
        if(document.readyState == "loading") {
            window.stop();
            // Show a progress-bar to indicate activity and then process the request
            // bar will automatically disappear since the document will be replaced
            let pbar = getProgressBar(document);
            pbar.style.visibility = 'visible';
            processXMLHTTPRequest(currentURL, false);
        }
        else {
            // Show a progress-bar to indicate activity and then process the request
            // bar will automatically disappear since the document will be replaced
            let pbar = getProgressBar(document);
            pbar.style.visibility = 'visible';
            processContentDoc(document, currentURL, false);
        }
    }
}

function RunOnSelection() {
    currentURL = location.toString();
   
    // Typically used when the page has at least partially loaded and user has selected some text
    // However this should work even if we are running on an already processed page; maybe the user wants to
    // prune the tranquilized content further and read just a portion of the article

    // Stop loading the document if it has not completed loading
    if(document.readyState == "loading") {
        window.stop();
    }

    // Obtain a DocumentFragment of the selected portion of the webpage
    let selection = document.getSelection();
    let range = selection.getRangeAt(0);
    let frag = range.cloneContents();

    // Show a progress-bar to indicate activity and then process the request
    // bar will automatically disappear since the document will be replaced
    let pbar = getProgressBar(document);
    pbar.style.visibility = 'visible';

    // Clone the current page and replace entire body with the DocumentFragment
    let contentDoc = document.cloneNode(true);
    let docBody = contentDoc.body;
    while (docBody.firstChild) {
        docBody.removeChild(docBody.firstChild);
    }
    docBody.appendChild(frag);

    // Now run tranquility to process the DocumentFragment
    processContentDoc(contentDoc, currentURL, false);
}

function RunAndSaveOnLoad() {
    currentURL = location.toString();
    // If we have already run tranquility, then just save content offline and exit
    if (document.readyState == "complete" && document.body.getElementsByClassName("tranquility").length > 0) {
        saveContentOffline(currentURL, document.cloneNode(true));
        return;
    }

    // If tranquility has not been run, then "tranquilize" the document and then save the content offline
    if(document.readyState == "loading") {
        window.stop();
    }
    // Show a progress-bar to indicate activity and then process the request
    // bar will automatically disappear since the document will be replaced
    let pbar = getProgressBar(document);
    pbar.style.visibility = 'visible';
    processXMLHTTPRequest(currentURL, true);
}

function processXMLHTTPRequest(url, saveOffline) {

    // Handle corner case to avoid mixed content security warnings/errors
    let getURL = url;
    if (getURL.substr(0,5) == 'https') {
        print(getURL);
        getURL = getURL.replace(/^http\:/, 'https:');
        print(getURL);
    }

    let oXHR = new XMLHttpRequest();
    oXHR.onreadystatechange = function() {
        print(oXHR.readyState  + ", " + oXHR.status);
        if(oXHR.readyState === 4) {
            if(oXHR.status === 200) {
                let oXHRDoc = oXHR.responseText;
                processResponse(oXHRDoc, url, saveOffline);
            }
            else {
                // Print error message to console and remove progress bar if any
                //
                print("Response status: " + oXHR.status);
                print("Unable to process document");
                let pbar = document.getElementById("tranquility_progress_bar");
                if (pbar) {
                    pbar.style.backgroundColor = '#FF0000';
                    setTimeout(function() {
                        pbar.parentNode.removeChild(pbar);
                    }, 3000);
                }
            }
        }        
    };
    print(getURL);
    oXHR.open("GET", getURL, true);

    // Fix to handle pages that use iso-8859-1/windows-1252 encoding
    //
    if (document.characterSet.toLowerCase() == "windows-1252") {
        oXHR.overrideMimeType('text/html; charset=iso-8859-1');
    }

    oXHR.send(null);
}
          
function processResponse (oXHRDoc, thisURL, saveOffline) {

    print("Processing Response...");

    let parser = new DOMParser();
    let contentDoc = parser.parseFromString(oXHRDoc, "text/html");
    processContentDoc(contentDoc, thisURL, saveOffline);
}

function processContentDoc(contentDoc, thisURL, saveOffline) {

    // First move to the top of the document; for some reason
    // window.scroll(0, 0) at the end of processing does not seem to
    // always work
    //
    document.documentElement.scrollTop = 0;

    // Remove all event handlers by "deep" cloning the document
    // instead of cloning each element (saves some time and
    // the code is cleaner); now cloning the entire document
    // instead of just cloning only the body
    //
    let clonedDoc = contentDoc.cloneNode(true);
    document.replaceChild(clonedDoc.documentElement, document.documentElement);

    contentDoc = document;

    // Remove all script tags
    //
    let scriptTags = ["SCRIPT", "NOSCRIPT"];
    for (let i = 0; i < scriptTags.length; i++) {
        removeTag(contentDoc, scriptTags[i]);
    }

    // Now replace document.documentElement; It looks like we need this step for
    // the window.getComputedStyle() function to work correctly
    // we can then copy over the document to the contentDoc variable and continue
    // as before
    //
    document.replaceChild(contentDoc.documentElement, document.documentElement);
    contentDoc = document;

    // First get a dfs search to index every single element in the
    // document
    let indexMap = {};
    indexElements(indexMap, contentDoc.body);

    // Backup any title/heading related tags to restore in case they are removed
    // by the deletion logic
    //
    let hElemsMap = {};
    cloneHElems(hElemsMap, contentDoc);

    // Collect any supporting links before processing the webpage
    let supporting_links = getSupportingLinks(contentDoc);
    print("Got supporting links...");

    // Remove some elements that are typically like hidden elements
    // but can add to the text size of a document; remove them so that
    // their effect on later logic (textContent.length value) is minimized
    //
    let likeHidden = ["HEADER", "FOOTER", "NAV", "SVG", "PATH", "LINK", "STYLE"];
    for (let i = 0; i < likeHidden.length; i++) {
        removeTag(contentDoc, likeHidden[i]);
    }

    // Remove unnecessary whitespaces and comments
    removeWhiteSpaceComments(contentDoc);
    //print("Removed white spaces and comments");

    // Cleanup the head and unnecessary tags
    // Delete All Hidden Elements before doing anything further
    // These could be hidden images, div, spans, spacers, etc...
    // Delete any content that has display = 'none' or visibility == 'hidden'
    // This was originally done only for spacer images, but seems like a meaningful thing
    // to do for all elements, given that all scripts are also deleted in the Tranquility view
    //

    // First get the size of the document before removing hidden content and make a clone
    // in case we need to revert
    //
    let sizeBeforeDelHidden = computeSize(contentDoc.documentElement);
    let bkpContentDoc = contentDoc.cloneNode(true);

    deleteHiddenElements(contentDoc, "*");
    print("Removed Hidden elements");

    let sizeAfterDelHidden = computeSize(contentDoc.documentElement);

    print(sizeBeforeDelHidden, sizeAfterDelHidden);

    // If the content after deletion of hidden elements is less than 10% of the
    // content before deletion of hidden elements and the size after deletion
    // is less than 200 characters, then it is possible that the
    // website is hiding content within hidden elements
    //
    // Revert to the document state before this step and continue...
    //
    if (sizeAfterDelHidden < 200 && sizeAfterDelHidden / sizeBeforeDelHidden < 0.1) {
        print("Problem removing hidden elements...");
        print("Website may be hiding content within hidden elements...");
        print("Reverting to backedup document and continuing...");
        print("Size Before: ", sizeBeforeDelHidden, "Size After: ", sizeAfterDelHidden);
        document.replaceChild(bkpContentDoc.documentElement, document.documentElement);
        contentDoc = document;
    }

    print("Size: ", computeSize(contentDoc.documentElement));

    // Remove zero sized images; this is just another way of hiding elements
    // otherwise, these can get cloned and reappear
    // resized to the reading width, which is very annoying
    // This has a side effect of removing images that have not yet loaded
    // The problem will be addressed in a later release
    //
    deleteZeroSizeImages(contentDoc);
    print("Removed Zero Sized Images");
    print("Size: ", computeSize(contentDoc.documentElement));

    // Ensure that we set a base element before we replace the
    // web page with the new content; otherwise, relative URL
    // links will be based on the incorrect URL present in the
    // window.location 
    // Then call convertLinksAbsolute to convert all relative
    // links to absolute links so that these links will also
    // work if we save this document for reading later
    //
    let baseElem = createNode(contentDoc, {type: 'BASE', attr: { href: thisURL } });

    let heads = contentDoc.getElementsByTagName('HEAD');
    for(let i = 0; i < heads.length; i++) {
        heads[i].appendChild(baseElem.cloneNode(true));
    }
    convertLinksAbsolute(contentDoc, thisURL);

    print("Processing document...");

    // Remove any links that have an onclick event (these are usually for sharing to social media)
    // removing such links is consistent with our preference to delete all javascript
    //
    print("Removing links with associated javascript events...");
    let all_links = contentDoc.getElementsByTagName("A");
    for (let i = all_links.length - 1; i >= 0; i--) {
        let onclickVal = all_links[i].getAttribute('onclick');
        if (onclickVal != null) {
            all_links[i].setAttribute('onclick', "void(0);");
        }
    }

    // If there is a single "MAIN" tag, then replace the entire document content with just the
    // contents of the main tag.  Trust that the content creator has done the correct thing.
    // If and article tag exists, then...
    // If there is a single "ARTICLE" tag, then replace the entire document content with just the
    // contents of the article.  Trust that the content creator has done the correct thing
    // (this is because articles are supposed to be within the main tag)
    //
    let mainsOrArticle = false;
    let mains = contentDoc.getElementsByTagName("main");
    let articles = contentDoc.getElementsByTagName("article");
    if (mains.length == 1) {
        let docBody = contentDoc.body;
        let mainContent = mains[0].cloneNode(true);
        if (computeSize(mainContent) > 200) {
            while (docBody.firstChild) {
                docBody.removeChild(docBody.firstChild);
            }
            docBody.appendChild(mainContent);
            print("Replaced body content with main contents...");
            mainsOrArticle = true;
        }
    }
    if (articles.length == 1) {
        let docBody = contentDoc.body;
        let mainArticle = articles[0].cloneNode(true);
        if (computeSize(mainArticle) > 200) {
            while (docBody.firstChild) {
                docBody.removeChild(docBody.firstChild);
            }
            docBody.appendChild(mainArticle);
            print("Replaced body content with article contents...");
            mainsOrArticle = true;
        }
    }
    print("Processed article/main content...");
    print("Size: ", computeSize(contentDoc.documentElement));

    // Remove unnecessary whitespaces and comments
    //removeWhiteSpaceComments(contentDoc);
    //print("Removed white spaces and comments");

    // Cleanup the head and unnecessary tags
    let delTags = ["STYLE", "LINK", "META", "SCRIPT", "NOSCRIPT", "IFRAME",
                   "SELECT", "DD", "INPUT", "TEXTAREA", "HEADER", "FOOTER",
                   "NAV", "FORM", "BUTTON", "PICTURE", "FIGURE", "SVG"];
    for(let i=0; i<delTags.length; i++) {
        let delTagExceptions = ["PICTURE", "FIGURE", "SVG"];
        if (mainsOrArticle) {
            if (!delTagExceptions.includes(delTags[i])) {
                removeTag(contentDoc, delTags[i]);
            }
        }
        else {
            removeTag(contentDoc, delTags[i]);
        }
        print("Size: ", computeSize(contentDoc.documentElement));
    }
    
    print("Cleaned up unnecessary tags and headers");
    print("Size: ", computeSize(contentDoc.documentElement));

    // Cleanup elements that have classnames that are typically not main content
    // This was included as a hidden element via css @media settings in 3.0.18
    // but moving it to a regexp for more flexibility (borrowing idea from readability)
    // since it is easier to undo the cleanup in javascript or add logic to skip
    // certain elements that seem to have actual content in them
    //
    let unlikelyCandidates = /^social|soc|^header|footer|related|recommended|sponsored|action|navigation|promo|adCaption|comment|dfp|adHolder|billboard|slide|-ad-|_ad_|control-bar|menu|disqus|popup|pop-up|crumb|more-stories/i
    let nodeIter = getNodeIterator(contentDoc.body, unlikelyCandidates, "className");
    let node = null;
    while ((node = nodeIter.nextNode())) {
        let exceptions = ["BODY", "MAIN", "ARTICLE"];
        if (exceptions.includes(node.nodeName.toUpperCase())) {
            continue;
        }
        let docSize = computeSize(contentDoc.body);
        let nodeSize = computeSize(node);

        if (nodeSize/docSize > 0.9) {
            continue;
        }
        print("Removing node with classname: ", node.className);
        print(nodeSize, docSize);
        node.parentNode.removeChild(node);
    }

    print("Cleaned up unlikely candidates");
    print("Size: ", computeSize(contentDoc.documentElement));

    // Reformat the header and use custom css
    reformatHeader(contentDoc);

    print("Reformatted headers...");

    // Moving the cloneImage calls after we have
    // cleaned up the unnecessary tags.  This can help filter of any
    // unneccessary icons ad images that are in these deleted tags
    // and get added back later.

    // Clone all the image nodes for later insertion
    let imgCollection = {};
    cloneImages(contentDoc.body, imgCollection);

    // Ensure that we set a base element before we replace the
    // Processing for ads related DIV's; several websites seem to use LI elements
    // within the ads DIV's, or for navigation links which are not required in the 
    // Tranquility view.  In this section, we try to delete DIV's that have at least 
    // x% of the DIV content within LI tags
    let pruneAdsTagList = ["UL", "DIV", "ARTICLE", "SECTION"];
    let totalSize = computeSize(contentDoc.documentElement);
    for(let p=0; p < pruneAdsTagList.length; p++) {
        pruneAdsTag(contentDoc, thisURL, pruneAdsTagList[p], 0.7, totalSize, imgCollection);
    }

    print("Pruned the AdsTag");
    print("Size: ", computeSize(contentDoc.documentElement));
   
    // Cleanup select tags that have content length smaller than minSize 
    // This helps clean up a number of junk DIV's before we get to real content
    // Can be made a parameter in later versions
    // First run with minSize ZERO
    // Removed TD and DD for now
    let pruneTagList = ["LI", "DIV", "OL", "UL", "FORM", "TABLE", "ARTICLE", "SECTION", "SPAN", "P"];
    let minSize = 0;
    totalSize = computeSize(contentDoc.documentElement);
    for(let p=0; p < pruneTagList.length; p++) {
        pruneTag(contentDoc, pruneTagList[p], 0.0, minSize, totalSize);
    } 
    // Next run with minsize 5 (for a reduced subset of the tags)
    // Removed TD, TABLE, and DD for now
    pruneTagList = ["FORM", "DIV", "ARTICLE", "SECTION"];
    minSize = 5;
    totalSize = computeSize(contentDoc.documentElement);
    for(let p=0; p < pruneTagList.length; p++) {
        pruneTag(contentDoc, pruneTagList[p], 0.0, minSize, totalSize);
    } 

    // Second pass
    // Remove any elements that have zero length textContent
    pruneTagList = ["LI", "DIV", "OL", "UL", "FORM", "TABLE", "ARTICLE", "SECTION", "SPAN", "P"];
    minSize = 0;
    totalSize = computeSize(contentDoc.documentElement);
    for(let p=0; p < pruneTagList.length; p++) {
        pruneTag(contentDoc, pruneTagList[p], 0.0, minSize, totalSize);
    } 

    print("Completed second pass pruning");
    
    // Try to remove unnecessary nested DIV's
    // They mess up the padding and margins; use only in moderate pruning
    // if the threshold is < 0.99999
    for(let i=0; i < 5; i++) {
        replaceParent(contentDoc, "DIV",  0.99999);
        replaceParent(contentDoc, "SPAN", 0.99999);
    }
    
    print("Completed Replace parent loops");

    // Format the tags in a nice readable font/style using custom css loaded in header
    let reformatTagList = ["UL", "OL", "LI", "DIV", "SPAN", "P", "FONT", "BODY", "H1", 
                           "H2", "H3", "PRE", "TABLE", "ARTICLE", "SECTION", "MAIN"];
    for(let r=0; r < reformatTagList.length; r++) {
        reformatTag(contentDoc, reformatTagList[r]);
    }

    print("Completed reformatting tags");

    // Time to add back the images that we have cloned
    //
    addBackElems(contentDoc, "IMG", imgCollection, indexMap);

    // Add back any title/h1 tags we backup that were removed incorrectly
    addBackElems(contentDoc, "H1", hElemsMap, indexMap);

    print("Reinserted images and H1 tags...");

    // Remove target attribute from all anchor elements
    // this will enable opening the link in the same browser tab
    //
    removeAnchorAttributes(contentDoc);
    print("Removed Anchor attributes");

    // Create the tranquility UI related elements
    create_ui_elements(contentDoc, supporting_links, thisURL);
    print("Created Tranquility UI elements");

    print("Finished processing document");

    // Finally apply all preferences and add Event listeners
    applyAllTranquilityPreferences();
    addBackEventListeners();

    // Try one last time to remove any hidden/script elements that did not get removed for any reason
    for (let i = 0; i < scriptTags.length; i++) {
        removeTag(contentDoc, scriptTags[i]);
    }
    for (let i = 0; i < likeHidden.length; i++) {
        removeTag(contentDoc, likeHidden[i]);
    }

    if (saveOffline) {
        saveContentOffline(thisURL, document.cloneNode(true));
    }
}

function removeWhiteSpaceComments(cdoc) {

    let cnodes = cdoc.childNodes;
    for(let i=cnodes.length -1; i > -1; i--) {
        // Make sure that PRE nodes are ignored
        // Otherwise, their spaces and line breaks are removed
        // destroying their formatting
               
        if(cnodes[i].nodeName == "PRE") {
            continue;
        }
        if(cnodes[i].nodeType == 1) {
            removeWhiteSpaceComments(cnodes[i]);
        }
        if(cnodes[i].nodeType == 3) {
            let allText = cnodes[i].data;
            cnodes[i].data = allText.replace(/\s{2,}/g, ' ');
        }
        if(cnodes[i].nodeType == 8 || cnodes[i].nodeType == 4) {
            cnodes[i].parentNode.removeChild(cnodes[i]);
        }
    }
}

function removeTag(cdoc, tagString) {

    print("Removing items with tag: ", tagString);
    let regexp = new RegExp(tagString, 'i');
    print(cdoc.body.getElementsByTagName(tagString).length);
    let nodeIter = getNodeIterator(cdoc.body, regexp, "nodeName");
    let node = null;
    let ncounter = 0;
    while ((node = nodeIter.nextNode())) {
        ncounter += 1;
        if(node.id == undefined || node.id.substr(0,11) !== "tranquility") {
            node.parentNode.removeChild(node);
        }
    }
    print("Removed ", ncounter, " items with tag: ", tagString);
}

function reformatHeader(cdoc) {
    
    let heads = cdoc.getElementsByTagName('HEAD');
    for(let i=0; i < heads.length; i++) {
        let hChildren = heads[i].getElementsByTagName("*");
        let titleNodeCount = 0;
        while(hChildren.length > titleNodeCount) {
            if (hChildren[titleNodeCount].nodeName.toUpperCase() !== "TITLE") {
                heads[i].removeChild(hChildren[titleNodeCount]);
            }
            else {
                titleNodeCount++;
            }
        }
    }    
}

function deleteHiddenElements(cdoc, tagString) {
    // Remove elements that have display==none or visibility==hidden
    let elems = cdoc.getElementsByTagName(tagString);

    let ignoreList = ["HEAD", "TITLE"];

    for(let i=elems.length - 1; i >=0;  i--)  {

        if (ignoreList.includes(elems[i].nodeName.toUpperCase())) {
            continue;
        }

        let cssProp = window.getComputedStyle(elems[i], null);
        let cssVisibility = cssProp.getPropertyValue("visibility");
        let cssDisplay = cssProp.getPropertyValue("display");

        if(((cssVisibility != undefined) && (cssVisibility == 'hidden')) ||
           ((cssDisplay != undefined) && (cssDisplay == 'none'))) {
            elems[i].parentNode.removeChild(elems[i]);
        }
    }
}


function pruneAdsTag(cdoc, url, tagString, thresholdPctg, totalSize, imgCollection) {

    let c = cdoc.getElementsByTagName(tagString);
    let len = c.length;
    let tElem;
    for(let i=0; i < len; i++) {
        tElem = c[len-i-1];

        let cLength = computeSize(tElem);
        let pctg = cLength/totalSize; 
        // If the DIV/SECTION/ARTICLE is empty remove it right away
        if(cLength == 0) {
            tElem.parentNode.removeChild(tElem);
        }
        // If the DIV does not contain a significant portion of the web content
        // AND the DIV contain mainly list elements then we can process to remove ads
        // Here, we use the "A" anchor node as a proxy for the LI node since each
        // navigation menu (or ads links menu) has a list of LI nodes that contain
        // anchor nodes with links to a new web page/section
        //
        else if(pctg < 0.8) { 
            let anchorNodes = tElem.getElementsByTagName("A");
            let anchorLength = 0;
            let num_words = 0;
            for(let j=0; j < anchorNodes.length; j++) { 
                // Ignore links that are # tags in the same document
                // These are typically table of content type links for the
                // current document and are useful to retain
                //
                if(anchorNodes[j].href.split("#")[0] == url.split("#")[0])
                    continue;
                anchorLength += computeSize(anchorNodes[j]);
                num_words += anchorNodes[j].textContent.split(/\s+/).length;
            }
            let avg_words_per_anchor = num_words/anchorNodes.length;
            let inner_div_pctg = anchorLength/cLength; 
            // If the DIV has > thresholdPctg of its content within anchor nodes
            // remove, the DIV.  Additionally we can also look at the number of words
            // per anchor, but for now, that is not enabled
            if (inner_div_pctg >= thresholdPctg) {
                let images = tElem.getElementsByTagName('img');
                if (images.length > 0) {
                    for (let k = 0; k < images.length; k++) {
                        let idx = images[k].getAttribute('data-dfsIndex');
                        if (idx in imgCollection) {
                            delete imgCollection[idx];
                        }
                    }
                }
                tElem.parentNode.removeChild(tElem); 
            }
        }
        else {
            // Do nothing
        }
    }
}

function pruneTag(cdoc, tagString, thresholdPctg, minSize, totalSize) {

    let c = cdoc.getElementsByTagName(tagString);
    let len = c.length;
    let tElem;
    for(let i=0; i < len; i++) {
        tElem = c[len-i-1];

        // If the DIV has a H1 child, then we want to retain the article
        // heading and not delete it.
        let h1elems = tElem.getElementsByTagName("H1");
        if(h1elems.length > 0) 
            continue;

        let cLength = computeSize(tElem);
        let pctg = cLength/totalSize; 
        // Experimental; do not delete if the text content is > threshold of innerHTML
        // currently hardcoded; trying to do better with blog style pages and comments
        let ilength = tElem.innerHTML.replace('/\s/g', '').length + 1;
        let inner_html_pctg = cLength/ilength; 
        if (((inner_html_pctg < 0.5) && (pctg < thresholdPctg)) || (cLength <= minSize)) {
            tElem.parentNode.removeChild(tElem); 
        }
        else {
            // Do nothing
        }
    }
}

function replaceParent(cdoc, tagString, thresholdPctg) {

    let c = cdoc.getElementsByTagName(tagString);
    let cArray = [];
    let len = c.length;
    for(let i=0; i < len; i++) {
        cArray[i] = c[i];
    }
    cArray.sort(function (a,b) { return b.innerHTML.length - a.innerHTML.length } );

    let tElem; 
    for(let i=0; i < len; i++) {
        tElem = cArray[len-i-1];
        if((tElem.parentNode != undefined) && (tElem.parentNode.tagName == tElem.tagName)) {
            let cLength = computeSize(tElem);
            let pLength = computeSize(tElem.parentNode);
            let pctg = cLength/pLength;
            if ((pctg > thresholdPctg)) {
                // If grandparent exists replace parent with this element
                // else, remove all siblings
                let grandparent = tElem.parentNode.parentNode;
                if(grandparent != undefined) 
                    grandparent.replaceChild(tElem.cloneNode(true), tElem.parentNode);
                else { 
                    let siblings = tElem.parentNode.childNodes;
                    for(let j=siblings.length - 1; j > -1; j--) {
                        if(siblings[j] !== tElem) {
                            tElem.parentNode.removeChild(siblings[j]);
                        }
                    }
                }
            }
            else {
            }
        }
    }
}

function reformatTag(cdoc, tagString) {

    let c = cdoc.getElementsByTagName(tagString);
    for(let i=0; i < c.length; i++) {
        c[i].removeAttribute('class');
        c[i].removeAttribute('style');
        c[i].removeAttribute('width');
        c[i].setAttribute('class', 'tranquility');
        
        // Exception for the preformatted text so that we can
        // apply only some of the formatting changes to preformatted text
        // for example, fontName must not be changes so that we have an
        // equal width character font for code readability, etc
        // 
        if (c[i].nodeName == "PRE") {
            c[i].setAttribute('class', 'tranquility_pre');
        }
    }
}


function computeSize(dElem) {

    // Compute size removes spaces to do a better job of true size calculations
    //
    if(dElem.innerHTML) {
        if(dElem.textContent) {
            return dElem.textContent.replace(/\s/g, '').length;
        }
        else if(dElem.innerText) {
            return dElem.innerText.replace(/\s/g, '').length;
        }
        else {
            return 0;
        }
    }
    else {
        return 0;
    }
}


function convertLinksAbsolute(node, baseURL) {
    let alinks = node.getElementsByTagName('A');    
    for(let i=0; i < alinks.length; i++) {
        // Fix where some pages with a "mail:" link fail when trying to construct
        // the new URL; wrap this in a try/catch to handle any links that cannot
        // be processed
        try {
            var absURL = new URL(alinks[i].href, baseURL);
            alinks[i].href = absURL.href;
        }
        catch(error) {
            print(error);
        }
    }
}


function getSupportingLinks(cDoc) {

    // Search for 'Single Page' links and load them in current window
    // Helps in simplifying the processing as well as in handling multi-page document

    let altString = browser.i18n.getMessage("singlePageString").split(",");
    let navString = browser.i18n.getMessage("navigationString").split(",");
    let navRegExp = /^\d+$/;
    
    let altURL;
    let altLink;
    let found = 0;

    let altlinks = cDoc.getElementsByTagName('A');
    // Insert all links into a temporary div for later use 
    let links_div = createNode(cDoc, {type: 'DIV', attr: { class:'tranquility_links', id:'tranquility_links' } });
    let nav_links_div = createNode(cDoc, {type: 'DIV', attr: { class:'tranquility_nav_links' } });
    let spacerString = "  ";
    let sp_elem = cDoc.createTextNode(spacerString);
    
    for(let i=0; i < altlinks.length; i++) {
        let altLinkClone = altlinks[i].cloneNode(true);
        // Replace the contents of the link with its text content
        // this can help cleanup images and other pointless tags/children
        // that can cause problems for tranquility
        altLinkClone.textContent = altLinkClone.textContent;
        removeWhiteSpaceComments(altLinkClone);
        //Collect any links that can be added to the "More Links" section
        if(altLinkClone.textContent.length >= 20) {
            let p_elem = createNode(cDoc, {type: 'P', attr: { class:'tranquility_links' } });
            p_elem.appendChild(altLinkClone.cloneNode(true));
            links_div.appendChild(p_elem.cloneNode(true));
        }
        // Collect any link that might be used for navigation in a multipage document
        let navstr = altLinkClone.textContent.replace(/\s/g, '');
        if(navstr && ((navString.indexOf(navstr.toUpperCase()) >= 0) || 
                      (navstr.search(navRegExp) != -1)) &&
          (!altLinkClone.getAttribute('onclick')) && 
          (altLinkClone.href) &&
          (altLinkClone.href != "#") &&
          (altLinkClone.href != (currentURL + "#")) &&
          (altLinkClone.href.substr(0,10) !== "javascript")) {
            nav_links_div.appendChild(altLinkClone.cloneNode(true));
            nav_links_div.appendChild(sp_elem.cloneNode(true));
        } 
    }
    nav_links_div = cleanupNavLinks(nav_links_div.cloneNode(true));
    return {links_div : links_div.cloneNode(true), 
            nav_links : nav_links_div.cloneNode(true) 
           };
}

function cleanupNavLinks(nlinks_div) {

    let nlinks = nlinks_div.getElementsByTagName('A');
    let nlinks_count = nlinks.length;
    let navRegExp = /^\d+$/;
    let nLinkExists = [];
    let intNavLinks = 0;

    for(let i=0; i < nlinks_count; i++) {
        let navStr = nlinks[i].textContent.replace(/\s/g, ''); 
        if(navStr.search(navRegExp) != -1)
            intNavLinks++;
    }

    for(let i=nlinks_count - 1; i > -1; i--) {
        let navStr = nlinks[i].textContent.replace(/\s/g, ''); 
        // Remove the link if the number within is greater than the total number
        // of navigation links collected.  This will eliminate arbitrary links
        // that have numbers within them
        //
        if((navStr.search(navRegExp) != -1) && (navStr > intNavLinks + 1))
            nlinks[i].parentNode.removeChild(nlinks[i]);
        // Remove links that are duplicates; some pages have navigation links at
        // the top and bottom of the page; no need for us to duplicate them
        //
        else if(nLinkExists[navStr] != undefined)
            nlinks[i].parentNode.removeChild(nlinks[i]);
        // Else remove comment style links from the navigation bar
        else if(nlinks[i].href.split("#")[0] == currentURL) {
            nlinks[i].parentNode.removeChild(nlinks[i]);
        }
        else {
            // Do nothing
        }
        nLinkExists[navStr] = 1;    
    }
    
    return nlinks_div;
}

function removeDuplicateAndBadLinks(cdoc, url, orig_links) {

    let encodedURL = encodeURIComponent(url.split("#")[0]);
    let re = new RegExp("^http:");

    let c = cdoc.getElementsByTagName('A');
    let bodyHrefs = [];
    for(let i=0; i < c.length; i++) {
        bodyHrefs[c[i].href] = 1;
    }

    let d = orig_links.getElementsByTagName('A');
    let moreHrefCounts = [];
    for(let i=0; i < d.length; i++) {
        if(moreHrefCounts[d[i].href] != undefined)
            moreHrefCounts[d[i].href] += 1;
        else
            moreHrefCounts[d[i].href] = 1;
    }

    let len = d.length;
    for(let j=0; j < len; j++) {
        let tElem = d[len-j-1];
        // Remove link if the "More Links" anchor node is either present in the main document
        // or if it is a #tag reference to some element in the main document
        if(bodyHrefs[tElem.href] != undefined) {
            tElem.parentNode.removeChild(tElem);
        }
        else if(tElem.href.substr(0,10) == "javascript") {
            tElem.parentNode.removeChild(tElem);
        }
        else if(encodeURIComponent(tElem.href.split("#")[0]) == encodedURL) {
            tElem.parentNode.removeChild(tElem);
        }
        else if(tElem.textContent.replace('^/s+', '').search(re) != -1) {
            tElem.parentNode.removeChild(tElem);
        }
        else if((moreHrefCounts[tElem.href] != undefined) && (moreHrefCounts[tElem.href] > 1)) {
            moreHrefCounts[tElem.href] -= 1;
            tElem.parentNode.removeChild(tElem);
        }
        else {
            // Nothing to do
        }
    }
    
    return orig_links.cloneNode(true);
}



function getAnchorNode(elem) {

    let urlString = elem.href;

    while((urlString == undefined) && (elem.parentNode != undefined)) {
        elem = elem.parentNode;     
        urlString = elem.href;
        if(urlString != undefined)
            return urlString;
    }
    return urlString;
}

function removeAnchorAttributes(cdoc) {

    let c = cdoc.getElementsByTagName('A');

    for(let i=0; i < c.length; i++) {

        // Do not process the tranquility_original_link_anchor
        //
        if (c[i].className == 'tranquility_original_link_anchor') {
            continue;
        }

        if(c[i].getAttribute('target')) {
            c[i].removeAttribute('target');
        }
        if(c[i].getAttribute('class')) {
            c[i].removeAttribute('class');
        }
        if(c[i].getAttribute('onmousedown')) {
            c[i].removeAttribute('onmousedown');
        }
        // Add all links to the 'tranquil_mode_links' to enable continuous browsing
        c[i].setAttribute('class', 'tranquil_browsing_mode_link');
    }    
}

function createNode(cdoc, props) {
    let thisNode = cdoc.createElement(props.type);
    let keys = Object.keys(props.attr);
    for (let i = 0; i < keys.length; i++) {
        let key = keys[i];
        thisNode.setAttribute(key, props.attr[key]);
    }
    return thisNode;
}

function getProgressBar(cdoc) {
    let pbar = cdoc.getElementById('tranquility_progress_bar');
    if (pbar == undefined) {
        pbar = createNode(cdoc, {type: 'DIV', attr: { class:'tranquility_progress_bar', id:'tranquility_progress_bar' } });
        pbar.style.visibility = 'hidden';
        if (cdoc.body != undefined) {
            cdoc.body.appendChild(pbar);
        }
    }
    return pbar;
}

function indexElements(indexMap, node) {

    if (node == null) return;

    indexMap[dfsIndex] = node;
    if (node.nodeType == 1) {
        node.setAttribute('data-dfsIndex', dfsIndex);
        node.setAttribute('data-origClassName', node.className);
    }
    dfsIndex += 1;
    let children = node.childNodes;
    for (let i = 0; i < children.length; i++) {
        indexElements(indexMap, children[i]);
    }
}

function cloneImages(cdoc, collection) {

    // This function also preserves the original width/height of the images
    // in data fields
    let images = cdoc.getElementsByTagName('IMG');
    for (let i = 0; i < images.length; i++) {
        if (images[i].src.substr(0,4) == "data") {
            continue;
        }
        let img = new Image();
        let idx = images[i].getAttribute('data-dfsIndex');
        img.src = images[i].src;
        img.setAttribute('data-dfsIndex', idx);
        img.alt = images[i].alt;

        collection[idx] = img;
        print(images[i].src + ": " + images[i].alt);
    }
}

function addBackElems(cdoc, tagName, bkpElems, indexMap) {

    let elems = cdoc.body.getElementsByTagName(tagName);
    let elemMap = {};
    for (let i = 0; i < elems.length; i++) {
        let idx = elems[i].getAttribute('data-dfsIndex');
        elemMap[idx] = i;
        //print(idx, elems[i]);
    }

    for (let key in bkpElems) {

        let elem = bkpElems[key];

        // Skip adding back element if the current cleanup has already
        // retained the original element
        //
        //print(elem.getAttribute('data-dfsIndex'), elem);
        if (key in elemMap) {
            //print("Found duplicate key...: ", key);
            continue;
        }

        insertByDFSIndex(elem, cdoc);
    }
}

function insertByDFSIndex(elem, cdoc) {

    let children = cdoc.body.getElementsByTagName("*");

    elem.className = 'tranquility';

    let nextSibling = null;
    let prevSibling = null;
    let prevSiblingIdx = -1;
    let elemIdx = parseInt(elem.getAttribute('data-dfsIndex'));
    print(elemIdx);
    for (let i = 0; i < children.length; i++) {
        if (children[i].nodeType == 1) {
            let idx = parseInt(children[i].getAttribute('data-dfsIndex'));
            if (idx < elemIdx && idx > prevSiblingIdx) {
                prevSibling = children[i];
                prevSiblingIdx = idx;
            }
            if (idx > elemIdx) {
                nextSibling = children[i];
                break;
            }
        }
        else {
        }
    }

    if (nextSibling != null) {
        nextSibling.insertAdjacentElement('beforebegin', elem);
    }
    else if (prevSibling != null) {
        prevSibling.insertAdjacentElement('afterend', elem);
    }
}


// Remove a node recursively based on the text-content of its parent
//
function removeNodeRecursive(thisNode) {
    let thisNodeTextLen = computeSize(thisNode);
    let parent = thisNode.parentNode;
    let parentTextLen = computeSize(parent);
    if (parentTextLen == thisNodeTextLen) {
        removeNodeRecursive(parent);
    }
    else {
        parent.removeChild(thisNode);
    }
}

// Remove any image elements that are not hidden, but have a height/width set to zero
//
function deleteZeroSizeImages(cdoc) {
    let images = cdoc.getElementsByTagName('IMG');
    for (let i = images.length-1; i >= 0; i--) {
        if (parseInt(images[i].getAttribute('height')) == 0 ||
            parseInt(images[i].getAttribute('width')) == 0 ||
            images[i].src.substr(0,4) == "data") {
            images[i].parentNode.removeChild(images[i]);
        }
    }
}

function requestZoomValue() {
    browser.runtime.sendMessage(
        {
            "action": "getZoomValue"
        });
}


function updateZoomValue(zoom) {
    print("Updating zoomValue to: " + zoom);
    zoomValue = zoom;
}


function cloneHElems(hdict, cdoc) {

    let hs = cdoc.getElementsByTagName("H1");
    for (let i = 0; i < hs.length; i++) {
        let elem = hs[i];
        let idx = elem.getAttribute('data-dfsIndex');
        hdict[idx] = elem.cloneNode(true);
    }
}

function getNodeIterator(root, regexp, attr) {

    return document.createNodeIterator(
        root,

        NodeFilter.SHOW_ALL,

        { acceptNode: function(node) {
            let nodeAttr = node.className;
            if (attr == "nodeName") {
                nodeAttr = node.nodeName;
            }
            if (regexp.test(nodeAttr)) {
                return NodeFilter.FILTER_ACCEPT;
            }
        }}
    );
}

/*
 * Assign tranquilize() as a listener for messages from the extension.
 * */
// browser.runtime.onMessage.addListener(tranquilize);

/* Don't do that ^, instead just tranquilize */
tranquilize({ tranquility_action: 'Run'});