☰

Torn - Level Progress Shower

Show your level progress on sidebar.

// ==UserScript==
// @name         Torn - Level Progress Shower
// @namespace    http://tampermonkey.net/
// @version      1.01
// @description  Show your level progress on sidebar.
// @author       e7cf09 [3441977]
// @icon         https://editor.torn.com/33b77f1c-dcd9-4d96-867f-5b578631d137-3441977.png
// @match        https://www.torn.com/*
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_xmlhttpRequest
// @grant        GM_registerMenuCommand
// @license      MIT
// ==/UserScript==

(function() {
    'use strict';

    let apiKey = GM_getValue('torn_api_key', '');
    let cachedData = GM_getValue('cached_level_data', null);
    let cacheTime = GM_getValue('cache_timestamp', 0);
    let lastCall = GM_getValue('last_api_call_time', 0);
    let callCount = GM_getValue('api_call_count', 0);
    let callTime = GM_getValue('api_call_timestamp', 0);
    let lastLevel = GM_getValue('last_seen_level', 0);

    const CACHE_DURATION = 24 * 60 * 60 * 1000;
    const INACTIVE_THRESHOLD = 365 * 24 * 60 * 60;
    const RATE_LIMIT = 60;
    const RATE_WINDOW = 60 * 1000;
    const MIN_INTERVAL = 1000; 

    let processing = false;
    let displayLevel = null;
    let status = '';

    function canCall() {
        const now = Date.now();

        if (now - callTime > RATE_WINDOW) {
            callCount = 0;
            callTime = now;
            GM_setValue('api_call_count', callCount);
            GM_setValue('api_call_timestamp', callTime);
        }

        if (callCount >= RATE_LIMIT) {
            return false;
        }

        if (now - lastCall < MIN_INTERVAL) {
            return false;
        }

        return true;
    }

    function recordCall() {
        const now = Date.now();
        callCount++;
        lastCall = now;

        GM_setValue('api_call_count', callCount);
        GM_setValue('last_api_call_time', lastCall);

        if (now - callTime > RATE_WINDOW) {
            callTime = now;
            GM_setValue('api_call_timestamp', callTime);
        }
    }

    function makeRequest(url) {
        return new Promise((resolve, reject) => {
            if (!canCall()) {
                reject(new Error('API rate limit exceeded. Please wait.'));
                return;
            }

            recordCall();

            GM_xmlhttpRequest({
                method: 'GET',
                url: url,
                onload: function(response) {
                    if (response.status === 200) {
                        try {
                            const data = JSON.parse(response.responseText);
                            if (data.error) {
                                reject(new Error(data.error.error || 'API Error'));
                            } else {
                                resolve(data);
                            }
                        } catch (e) {
                            reject(new Error('Invalid JSON response'));
                        }
                    } else {
                        reject(new Error(`HTTP ${response.status}: ${response.statusText}`));
                    }
                },
                onerror: function(error) {
                    reject(new Error('Network error'));
                }
            });
        });
    }

    async function sleep(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }

    async function getUserLevel() {
        const url = `https://api.torn.com/v2/user/hof?key=${apiKey}`;
        const data = await makeRequest(url);
        return {
            level: data.hof.level.value,
            rank: data.hof.level.rank
        };
    }

    async function getHOF(limit = 100, offset = 0) {
        const url = `https://api.torn.com/v2/torn/hof?limit=${limit}&offset=${offset}&cat=level&key=${apiKey}`;
        const data = await makeRequest(url);
        return data.hof;
    }

    async function getUserHOF(userId) {
        const url = `https://api.torn.com/v2/user/${userId}/hof?key=${apiKey}`;
        const data = await makeRequest(url);
        return data.hof.level.rank;
    }

    async function findInactivePos(targetLevel) {
        const currentTime = Math.floor(Date.now() / 1000);
        
        const level1Pos = await getUserHOF(1364774);
        await sleep(MIN_INTERVAL);
        
        let left = 1;
        let right = level1Pos;
        let position = -1;
        
        while (left + 100 <= right) {
            const mid = Math.floor((left + right) / 2 - 50);
            
            try {
                const players = await getHOF(100, mid);
                await sleep(MIN_INTERVAL);
                
                let found = false;
                let higher = false;
                let lower = false;

                for (let i = 0; i < 100; i++) {
                    if (players[i].level === targetLevel) {
                        found = true;
                    }
                    if (players[i].level > targetLevel) {
                        higher = true;
                    } else if (players[i].level < targetLevel) {
                        lower = true;
                    }
                }
                
                if (higher && !found && !lower) {
                    left = mid + 100;
                } else if (higher && found && !lower) {
                    position = mid;
                    break;
                } else {
                    right = mid - 1;
                }
            } catch (error) {
                console.error('Error in binary search:', error);
                throw error;
            }
        }
        
        if (position === -1) {
            position = left;
        }
        
        let bestPos = -1;
        let bestId = null;
        let bestAction = null;
        let found = false;
        
        let currentOffset = position;
        while (1) {
            
            try {
                const players = await getHOF(100, currentOffset);
                await sleep(MIN_INTERVAL);
                
                for (let i = 0; i < players.length; i++) {
                    const player = players[i];
                        if (player.level === targetLevel) {
                        const daysSince = (currentTime - player.last_action) / (24 * 60 * 60);
                        if (daysSince > 365) {
                            bestPos = player.position;
                            bestId = player.id;
                            bestAction = player.last_action;
                            found = true;
                            break;
                        }
                    }
                }
                if (found) {
                    break;
                }
                currentOffset += 100;

            } catch (error) {
                console.error(`Error fetching data at offset ${currentOffset}:`, error);
                currentOffset += 100;
            }
        }
        
        if (!found) {
            return null;
        }
        
        return {
            position: bestPos,
            playerId: bestId,
            lastAction: bestAction,
            fetchTime: currentTime
        };
    }

    function validateInactive(playerData) {
        const currentTime = Math.floor(Date.now() / 1000);
        return playerData.lastAction < playerData.fetchTime;
    }

    async function calculateRelativePos() {
        try {
            const userLevel = await getUserLevel();
            await sleep(MIN_INTERVAL);

            GM_setValue('last_seen_level', userLevel.level);

            GM_setValue('process_step', 'user_level_fetched');
            GM_setValue('process_user_level', userLevel.level);
            GM_setValue('process_user_rank', userLevel.rank);
            GM_setValue('process_timestamp', Date.now());

            if (userLevel.level >= 100) {
                const result = {
                    level: userLevel.level,
                    rank: userLevel.rank,
                    relativePosition: 0,
                    finalLevel: 100.00,
                    lowerLevelInactiveData: null,
                    currentLevelInactiveData: null
                };

                GM_setValue('cached_level_data', result);
                GM_setValue('cache_timestamp', Date.now());
                GM_setValue('process_step', 'completed');

                return 100.00;
            }

            const lowerInactive = await findInactivePos(userLevel.level - 1);

            GM_setValue('process_step', 'lower_level_fetched');
            GM_setValue('process_lower_level_inactive_data', JSON.stringify(lowerInactive));

            const currentInactive = await findInactivePos(userLevel.level);

            GM_setValue('process_step', 'current_level_fetched');
            GM_setValue('process_current_level_inactive_data', JSON.stringify(currentInactive));

            if (!validateInactive(lowerInactive) || !validateInactive(currentInactive)) {
                throw new Error('Inactive player validation failed - need to refetch data');
            }

            if (lowerInactive.position === -1 || currentInactive.position === -1) {
                return userLevel.level;
            }

            const userRank = userLevel.rank;
            const lastCurrentPos = lowerInactive.position;
            const currentPos = currentInactive.position;

            const relativePos = (lastCurrentPos - userRank) / (lastCurrentPos - currentPos);
            let roundedRelative = Math.round(relativePos * 100) / 100;

            if (userLevel.level < 100) {
                roundedRelative = Math.min(roundedRelative, 0.99);
            }

            const finalLevel = userLevel.level + roundedRelative;

            const result = {
                level: userLevel.level,
                rank: userLevel.rank,
                relativePosition: roundedRelative,
                finalLevel: finalLevel,
                lowerLevelInactiveData: lowerInactive,
                currentLevelInactiveData: currentInactive
            };

            GM_setValue('cached_level_data', result);
            GM_setValue('cache_timestamp', Date.now());

            GM_setValue('process_step', 'completed');
            GM_setValue('process_final_level', finalLevel);

            return finalLevel;
        } catch (error) {

            GM_setValue('process_step', 'error');
            GM_setValue('process_error', error.message);

            if (error.message.includes('API') || error.message.includes('key')) {
                return null;
            }

            return 0;
        }
    }

    async function validateKey(key) {
        try {
            const url = `https://api.torn.com/v2/key/info?key=${key}`;
            const response = await new Promise((resolve, reject) => {
                GM_xmlhttpRequest({
                    method: 'GET',
                    url: url,
                    onload: function(response) {
                        if (response.status === 200) {
                            try {
                                const data = JSON.parse(response.responseText);
                                resolve(data);
                            } catch (e) {
                                reject(new Error('Invalid JSON response'));
                            }
                        } else {
                            reject(new Error(`HTTP ${response.status}: ${response.statusText}`));
                        }
                    },
                    onerror: function(error) {
                        reject(new Error('Network error'));
                    }
                });
            });

            if (response.info && response.info.access && response.info.access.level >= 1) {
                return { valid: true, level: response.info.access.level };
            } else {
                return { valid: false, error: 'incorrect key' };
            }
        } catch (error) {
            return { valid: false, error: error.message };
        }
    }

    function showConfig() {
        const overlay = document.createElement('div');
        overlay.style.cssText = 'position:fixed;top:0;left:0;width:100%;height:100%;background:rgba(0,0,0,0.5);z-index:9999;';

        const modal = document.createElement('div');
        modal.style.cssText = 'position:fixed;top:50%;left:50%;transform:translate(-50%,-50%);background:white;padding:20px;border:2px solid #333;z-index:10000;border-radius:8px;box-shadow:0 4px 6px rgba(0,0,0,0.1);';
        modal.innerHTML = `
            <h3>Torn API Configuration</h3>
            <p>Enter your public Torn API key:</p>
            <input type="text" id="keyInput" value="${apiKey}" placeholder="e.g., HhmiKs9LjgBN2UV7" style="width:300px;padding:8px;margin:10px 0;border:1px solid #ccc;border-radius:4px;">
            <br>
            <div id="validMsg" style="margin:10px 0;color:red;font-size:12px;"></div>
            <button id="saveKey" style="background:#007bff;color:white;border:none;padding:8px 16px;margin:5px;border-radius:4px;cursor:pointer;">Validate & Save</button>
            <button id="cancelKey" style="background:#007bff;color:white;border:none;padding:8px 16px;margin:5px;border-radius:4px;cursor:pointer;">Cancel</button>
            <button id="clearCache" style="background:#007bff;color:white;border:none;padding:8px 16px;margin:5px;border-radius:4px;cursor:pointer;">Clear Cache</button>
        `;

        overlay.appendChild(modal);
        document.body.appendChild(overlay);

        document.getElementById('saveKey').onclick = async function() {
            const newKey = document.getElementById('keyInput').value.trim();
            const validDiv = document.getElementById('validMsg');
            const saveBtn = document.getElementById('saveKey');

            if (!newKey) {
                validDiv.textContent = 'Please enter an API key';
                validDiv.style.color = 'red';
                return;
            }

            validDiv.textContent = 'Validating API key...';
            validDiv.style.color = 'blue';
            saveBtn.disabled = true;
            saveBtn.textContent = 'Validating...';

            const validation = await validateKey(newKey);

            if (validation.valid) {
                validDiv.textContent = 'API key saved successfully!';
                validDiv.style.color = 'green';

                apiKey = newKey;
                GM_setValue('torn_api_key', apiKey);
                GM_setValue('needs_full_recalc', true);

                GM_setValue('cached_level_data', null);
                GM_setValue('cache_timestamp', 0);
                displayLevel = null;
                processing = false;

                setTimeout(() => {
                    document.body.removeChild(overlay);
                }, 1500);
            } else {
                validDiv.textContent = 'Invalid API key';
                validDiv.style.color = 'red';
                saveBtn.disabled = false;
                saveBtn.textContent = 'Validate & Save';
            }
        };

        document.getElementById('cancelKey').onclick = function() {
            document.body.removeChild(overlay);
        };

        document.getElementById('clearCache').onclick = function() {
            GM_setValue('cached_level_data', null);
            GM_setValue('cache_timestamp', 0);
            clearProcess();
            displayLevel = null;
            processing = false;
        };

        overlay.onclick = function(e) {
            if (e.target === overlay) {
                document.body.removeChild(overlay);
            }
        };
    }

    async function checkNeedsRecalc(cached) {
        try {
            const userLevel = await getUserLevel();
            await sleep(MIN_INTERVAL);
            
            if (userLevel.level !== cached.level) {
                return true;
            }
            
            if (cached.lowerLevelInactiveData && cached.currentLevelInactiveData) {
                const currentTime = Math.floor(Date.now() / 1000);
                
                if (cached.lowerLevelInactiveData.lastAction > cached.lowerLevelInactiveData.fetchTime ||
                    cached.currentLevelInactiveData.lastAction > cached.currentLevelInactiveData.fetchTime) {
                    return true;
                }
            }
            
            return false;
        } catch (error) {
            console.error('Error checking if full recalculation needed:', error);
            return true;
        }
    }

    async function updateRank(cached) {
        try {
            
            const userLevel = await getUserLevel();
            await sleep(MIN_INTERVAL);
            
            const userRank = userLevel.rank;
            const lastCurrentPos = cached.lowerLevelInactiveData.position;
            const currentPos = cached.currentLevelInactiveData.position;
            
            const relativePos = (lastCurrentPos - userRank) / (lastCurrentPos - currentPos);
            let roundedRelative = Math.round(relativePos * 100) / 100;
            
            if (cached.level < 100) {
                roundedRelative = Math.min(roundedRelative, 0.99);
            }
            
            const finalLevel = cached.level + roundedRelative;
            
            cached.rank = userRank;
            cached.relativePosition = roundedRelative;
            cached.finalLevel = finalLevel;
            
            GM_setValue('cached_level_data', cached);
            GM_setValue('cache_timestamp', Date.now());
            
            return finalLevel;
        } catch (error) {
            console.error('Error updating with current rank:', error);
            return cached.finalLevel;
        }
    }

    async function getDisplayLevel() {
        if (!apiKey) {
            return null;
        }

        if (processing) {
            return null;
        }

        const needsRecalc = GM_getValue('needs_full_recalc', false);
        if (needsRecalc) {
            GM_setValue('needs_full_recalc', false);
            GM_setValue('cached_level_data', null);
            GM_setValue('cache_timestamp', 0);
        }

        const now = Date.now();
        if (now - lastCall < RATE_WINDOW && cachedData) {
            return cachedData.finalLevel;
        }

        if (cachedData && (now - cacheTime < CACHE_DURATION)) {
            const needsRecalc = await checkNeedsRecalc(cachedData);
            
            if (!needsRecalc) {
                return await updateRank(cachedData);
            }
        }

        const processStep = GM_getValue('process_step', '');
        const processTime = GM_getValue('process_timestamp', 0);

        if (processStep && (now - processTime < 5 * 60 * 1000)) {
            try {
                if (processStep === 'completed') {
                    const finalLevel = GM_getValue('process_final_level', 0);
                    if (finalLevel > 0) {
                        clearProcess();
                        return finalLevel;
                    }
                } else if (processStep === 'current_level_fetched') {
                    const userLevel = GM_getValue('process_user_level', 0);
                    const userRank = GM_getValue('process_user_rank', 0);
                    const lowerInactive = JSON.parse(GM_getValue('process_lower_level_inactive_data', '{}'));
                    const currentInactive = JSON.parse(GM_getValue('process_current_level_inactive_data', '{}'));

                    if (userLevel > 0 && lowerInactive.position && currentInactive.position) {

                        if (!validateInactive(lowerInactive) || !validateInactive(currentInactive)) {
                            throw new Error('Inactive player validation failed - need to refetch data');
                        }

                        const relativePos = (userRank - currentInactive.position) / (lowerInactive.position - currentInactive.position);
                        let roundedRelative = Math.round(relativePos * 100) / 100;

                        if (userLevel < 100) {
                            roundedRelative = Math.min(roundedRelative, 0.99);
                        }

                        const finalLevel = userLevel + roundedRelative;

                        const result = {
                            level: userLevel,
                            rank: userRank,
                            relativePosition: roundedRelative,
                            finalLevel: finalLevel,
                            lowerLevelInactiveData: lowerInactive,
                            currentLevelInactiveData: currentInactive
                        };

                        GM_setValue('cached_level_data', result);
                        GM_setValue('cache_timestamp', Date.now());

                        clearProcess();

                        return finalLevel;
                    }
                }
            } catch (error) {
                console.error('Error resuming from saved progress:', error);
                clearProcess();
            }
        }

        if (processStep && (now - processTime >= 5 * 60 * 1000)) {
            clearProcess();
        }

        processing = true;

        try {
            const result = await calculateRelativePos();
            if (result === null) {
                processing = false;
                return null;
            }
            displayLevel = result;
            processing = false;
            return result;
        } catch (error) {
            processing = false;
            return null;
        }
    }

    function clearProcess() {
        GM_setValue('process_step', '');
        GM_setValue('process_user_level', 0);
        GM_setValue('process_user_rank', 0);
        GM_setValue('process_lower_level_inactive_data', '');
        GM_setValue('process_current_level_inactive_data', '');
        GM_setValue('process_timestamp', 0);
        GM_setValue('process_final_level', 0);
        GM_setValue('process_error', '');
    }

    let hasUpdatedThisSession = false;

    async function optimizedChange() {
        const needsRecalc = GM_getValue('needs_full_recalc', false);
        if (hasUpdatedThisSession && !needsRecalc) {
            return;
        }

        const blocks = document.querySelectorAll('.point-block___rQyUK');

        for (let block of blocks) {
            const nameSpan = block.querySelector('.name___ChDL3');
            const valueSpan = block.querySelector('.value___mHNGb');

            if (nameSpan && nameSpan.textContent.trim() === 'Level:' && valueSpan) {
                const originalLevel = parseInt(valueSpan.textContent);

                if (originalLevel !== lastLevel && lastLevel !== 0) {
                    GM_setValue('cached_level_data', null);
                    GM_setValue('cache_timestamp', 0);
                    displayLevel = null;
                    processing = false;
                    GM_setValue('last_seen_level', originalLevel);
                    GM_setValue('needs_full_recalc', true);
                    hasUpdatedThisSession = false;
                }

                if (!hasUpdatedThisSession || needsRecalc) {
                    const level = await getDisplayLevel();

                    if (level !== null) {
                        valueSpan.textContent = level.toFixed(2);
                    }
                    hasUpdatedThisSession = true;
                    GM_setValue('needs_full_recalc', false);
                }

                break;
            }
        }
    }

    document.addEventListener('keydown', function(e) {
        if (e.ctrlKey && e.shiftKey && e.key === 'T') {
            showConfig();
        }
    });

    if (typeof GM_registerMenuCommand !== 'undefined') {
        GM_registerMenuCommand('Configure API Key', showConfig);
    }

    if (apiKey) {
        const firstRun = GM_getValue('first_run_completed', false);
        if (!firstRun) {
            GM_setValue('needs_full_recalc', true);
            GM_setValue('first_run_completed', true);
        }

        const processStep = GM_getValue('process_step', '');
        const processTime = GM_getValue('process_timestamp', 0);
        const now = Date.now();

        if (processStep && processStep !== 'completed' && processStep !== 'error' &&
            (now - processTime < 5 * 60 * 1000)) {
        }
    }

    optimizedChange();

    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', optimizedChange);
    } else {
        optimizedChange();
    }

    const observer = new MutationObserver(function(mutations) {
        let shouldCheck = false;
        mutations.forEach(function(mutation) {
            if (mutation.addedNodes.length > 0) {
                for (let node of mutation.addedNodes) {
                    if (node.nodeType === 1 && (node.classList.contains('point-block___rQyUK') || node.querySelector('.point-block___rQyUK'))) {
                        shouldCheck = true;
                        break;
                    }
                }
            }
        });

        if (shouldCheck) {
            optimizedChange();
        }
    });

    observer.observe(document.body, {
        childList: true,
        subtree: true,
        attributes: false,
        characterData: false
    });
})();