// Overrides the global fetch and XMLHttpRequest open methods to modify the request URLs.
// Also overrides the attribute setter prototype to modify the request URLs
// fetch("/relative_script.js") -> fetch("http://localhost:8080/relative_script.js")
(() => {
   const blacklistedSchemes = [
    "ftp:",
    "mailto:",
    "tel:",
    "file:",
    "blob:",
    "javascript:",
    "about:",
    "magnet:",
    "ws:",
    "wss:",
   ];

   function rewriteURL(url) {
        const oldUrl = url 
        if (!url) return url
        let isStr = (typeof url.startsWith === 'function')
        if (!isStr) return url

        // don't rewrite special URIs
        if (blacklistedSchemes.includes(url)) return url;

        //const proxyOrigin = globalThis.window.location.origin;
        const proxyOrigin = "R_PROXYURL";
        //const origin = (new URL(decodeURIComponent(globalThis.window.location.pathname.substring(1)))).origin
        const origin = "R_BASEURL";

        // don't rewrite invalid URIs
        try { new URL(url, origin) } catch { return url }

        // don't double rewrite
        if (url.startsWith(proxyOrigin)) return url;
        if (url.startsWith(`/${proxyOrigin}`)) return url;
        if (url.startsWith(`/${origin}`)) return url;
        if (url.startsWith(`/http://`)) return url;
        if (url.startsWith(`/https://`)) return url;
        if (url.startsWith(`/http%3A%2F%2F`)) return url;
        if (url.startsWith(`/https%3A%2F%2F`)) return url;
        if (url.startsWith(`/%2Fhttp`)) return url;

        //console.log(`proxychain: origin: ${origin} // proxyOrigin: ${proxyOrigin} // original: ${oldUrl}`)

        if (url.startsWith("//")) {
            url = `/${origin}/${encodeURIComponent(url.substring(2))}`;
        } else if (url.startsWith("/")) {
            url = `/${origin}/${encodeURIComponent(url.substring(1))}`;
        } else if (url.startsWith(origin)) {
            url = `/${encodeURIComponent(url)}` 
        } else if (url.startsWith("http://") || url.startsWith("https://")) {
            url = `/${proxyOrigin}/${encodeURIComponent(url)}`;
        }
        console.log(`proxychain: rewrite JS URL: ${oldUrl} -> ${url}`)
        return url;
   };

    // sometimes anti-bot protections like cloudflare or akamai bot manager check if JS is hooked
    function hideMonkeyPatch(objectOrName, method, originalToString) {
        let obj;
        let isGlobalFunction = false;
    
        if (typeof objectOrName === 'string') {
            obj = globalThis[objectOrName];
            isGlobalFunction = (typeof obj === 'function') && (method === objectOrName);
        } else {
            obj = objectOrName;
        }
    
        if (isGlobalFunction) {
            const originalFunction = obj;
            globalThis[objectOrName] = function(...args) {
                return originalFunction.apply(this, args);
            };
            globalThis[objectOrName].toString = () => originalToString;
        } else if (obj && typeof obj[method] === 'function') {
            const originalMethod = obj[method];
            obj[method] = function(...args) {
                return originalMethod.apply(this, args);
            };
            obj[method].toString = () => originalToString;
        } else {
            console.warn(`proxychain: cannot hide monkey patch: ${method} is not a function on the provided object.`);
        }
    }

   // monkey patch fetch
   const oldFetch = fetch;
   fetch = async (url, init) => {
        return oldFetch(rewriteURL(url), init)
   }
   hideMonkeyPatch('fetch', 'fetch', 'function fetch() { [native code] }')

   // monkey patch xmlhttprequest
   const oldOpen = XMLHttpRequest.prototype.open;
   XMLHttpRequest.prototype.open = function(method, url, async = true, user = null, password = null) {
       return oldOpen.call(this, method, rewriteURL(url), async, user, password);
   };
   hideMonkeyPatch(XMLHttpRequest.prototype, 'open', 'function(){if("function"==typeof eo)return eo.apply(this,arguments)}');

   const oldSend = XMLHttpRequest.prototype.send;
   XMLHttpRequest.prototype.send = function(method, url) {
       return oldSend.call(this, method, rewriteURL(url));
   };
   hideMonkeyPatch(XMLHttpRequest.prototype, 'send', 'function(){if("function"==typeof eo)return eo.apply(this,arguments)}');


   // monkey patch service worker registration
   const oldRegister = ServiceWorkerContainer.prototype.register;
   ServiceWorkerContainer.prototype.register = function(scriptURL, options) {
        return oldRegister.call(this, rewriteURL(scriptURL), options)
   }
   hideMonkeyPatch(ServiceWorkerContainer.prototype, 'register', 'function register() { [native code] }')

   // monkey patch URL.toString() method 
   const oldToString = URL.prototype.toString
   URL.prototype.toString = function() {
        let originalURL = oldToString.call(this)
        return rewriteURL(originalURL)
   }
   hideMonkeyPatch(URL.prototype, 'toString', 'function toString() { [native code] }')

   // monkey patch URL.toJSON() method 
   const oldToJson = URL.prototype.toString
   URL.prototype.toString = function() {
        let originalURL = oldToJson.call(this)
        return rewriteURL(originalURL)
   }
   hideMonkeyPatch(URL.prototype, 'toString', 'function toJSON() { [native code] }')

   // Monkey patch URL.href getter and setter
    const originalHrefDescriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'href');
    Object.defineProperty(URL.prototype, 'href', {
        get: function() {
            let originalHref = originalHrefDescriptor.get.call(this);
            return rewriteURL(originalHref)
        },
        set: function(newValue) {
            originalHrefDescriptor.set.call(this, rewriteURL(newValue));
        }
    });

    // TODO: do one more pass of this by manually traversing the DOM
    // AFTER all the JS and page has loaded just in case 

    // Monkey patch setter 
    const elements = [
        { tag: 'a', attribute: 'href' },
        { tag: 'img', attribute: 'src' },
        // { tag: 'img', attribute: 'srcset' }, // TODO: handle srcset
        { tag: 'script', attribute: 'src' },
        { tag: 'link', attribute: 'href' },
        { tag: 'link', attribute: 'icon' },
        { tag: 'iframe', attribute: 'src' },
        { tag: 'audio', attribute: 'src' },
        { tag: 'video', attribute: 'src' },
        { tag: 'source', attribute: 'src' },
        // { tag: 'source', attribute: 'srcset' }, // TODO: handle srcset
        { tag: 'embed', attribute: 'src' },
        { tag: 'embed', attribute: 'pluginspage' },
        { tag: 'html', attribute: 'manifest' },
        { tag: 'object', attribute: 'src' },
        { tag: 'input', attribute: 'src' },
        { tag: 'track', attribute: 'src' },
        { tag: 'form', attribute: 'action' },
        { tag: 'area', attribute: 'href' },
        { tag: 'base', attribute: 'href' },
        { tag: 'blockquote', attribute: 'cite' },
        { tag: 'del', attribute: 'cite' },
        { tag: 'ins', attribute: 'cite' },
        { tag: 'q', attribute: 'cite' },
        { tag: 'button', attribute: 'formaction' },
        { tag: 'input', attribute: 'formaction' },
        { tag: 'meta', attribute: 'content' },
        { tag: 'object', attribute: 'data' },
    ];

    elements.forEach(({ tag, attribute }) => {
        const proto = document.createElement(tag).constructor.prototype;
        const descriptor = Object.getOwnPropertyDescriptor(proto, attribute);
        if (descriptor && descriptor.set) {
            Object.defineProperty(proto, attribute, {
                ...descriptor,
                set(value) {
                    // calling rewriteURL will end up calling a setter for href,
                    // leading to a recusive loop and a Maximum call stack size exceeded
                    // error, so we guard against this with a local semaphore flag
                    const isRewritingSetKey = Symbol.for('isRewritingSet');
                    if (!this[isRewritingSetKey]) {
                        this[isRewritingSetKey] = true;
                        descriptor.set.call(this, rewriteURL(value));
                        //descriptor.set.call(this, value);
                        this[isRewritingSetKey] = false;
                    } else {
                        // Directly set the value without rewriting
                        descriptor.set.call(this, value);
                    }
                },
                get() {
                    const isRewritingGetKey = Symbol.for('isRewritingGet');
                    if (!this[isRewritingGetKey]) {
                        this[isRewritingGetKey] = true;
                        let oldURL = descriptor.get.call(this);
                        let newURL = rewriteURL(oldURL);
                        this[isRewritingGetKey] = false;
                        return newURL
                    } else {
                        return descriptor.get.call(this);
                    }
                }
            });
        }
    });


    // sometimes, libraries will set the Element.innerHTML or Element.outerHTML directly with a string instead of setters.
    // in this case, we intercept it, create a fake DOM, parse it and then rewrite all attributes that could
    // contain a URL. Then we return the replacement innerHTML/outerHTML with redirected links.
    function rewriteInnerHTML(html, elements) {
        const isRewritingHTMLKey = Symbol.for('isRewritingHTML');
    
        // Check if already processing
        if (document[isRewritingHTMLKey]) {
            return html;
        }
    
        const tempContainer = document.createElement('div');
        document[isRewritingHTMLKey] = true;
    
        try {
            tempContainer.innerHTML = html;
        
            // Create a map for quick lookup
            const elementsMap = new Map(elements.map(e => [e.tag, e.attribute]));
        
            // Loop-based DOM traversal
            const nodes = [...tempContainer.querySelectorAll('*')];
            for (const node of nodes) {
                const attribute = elementsMap.get(node.tagName.toLowerCase());
                if (attribute && node.hasAttribute(attribute)) {
                    const originalUrl = node.getAttribute(attribute);
                    const rewrittenUrl = rewriteURL(originalUrl);
                    node.setAttribute(attribute, rewrittenUrl);
                }
            }
    
            return tempContainer.innerHTML;
        } finally {
            // Clear the flag
            document[isRewritingHTMLKey] = false;
        }
    }


    // Store original setters
const originalSetters = {};

    ['innerHTML', 'outerHTML'].forEach(property => {
        const descriptor = Object.getOwnPropertyDescriptor(Element.prototype, property);
        if (descriptor && descriptor.set) {
            originalSetters[property] = descriptor.set;

            Object.defineProperty(Element.prototype, property, {
                ...descriptor,
                set(value) {
                    const isRewritingHTMLKey = Symbol.for('isRewritingHTML');
                    if (!this[isRewritingHTMLKey]) {
                        this[isRewritingHTMLKey] = true;
                        try {
                            // Use custom logic
                            descriptor.set.call(this, rewriteInnerHTML(value, elements));
                        } finally {
                            this[isRewritingHTMLKey] = false;
                        }
                    } else {
                        // Use original setter in recursive call
                        originalSetters[property].call(this, value);
                    }
                }
            });
        }
    });


})();



(() => {
    document.addEventListener('DOMContentLoaded', (event) => {
        initIdleMutationObserver();
    });
    
    function initIdleMutationObserver() {
        let debounceTimer;
        const debounceDelay = 500; // adjust the delay as needed
    
        const observer = new MutationObserver((mutations) => {
            // Clear the previous timer and set a new one
            clearTimeout(debounceTimer);
            debounceTimer = setTimeout(() => {
                execute();
                observer.disconnect(); // Disconnect after first execution
            }, debounceDelay);
        });
    
        const config = { attributes: false, childList: true, subtree: true };
        observer.observe(document.body, config);
    }
    
    function execute() {
        console.log('DOM is now idle. Executing...');
    }

})();