<!-- WordPress Name Picker - English Version -->
<div id="name-picker-app">
    <style>
        #name-picker-app {
            font-family: 'Arial', sans-serif;
            max-width: 800px;
            margin: 0 auto;
            padding: 20px;
            background: linear-gradient(135deg, #edf2bb 0%, #a5dfe8 25%, #4cb0c2 50%, #a8d5e6 75%, #c8caed 100%);
            background-size: 300% 300%;
            animation: npBackgroundGradient 8s ease infinite;
            border-radius: 15px;
            box-shadow: 0 10px 30px rgba(0,0,0,0.1);
        }

        @keyframes npBackgroundGradient {
            0% { background-position: 0% 50%; }
            50% { background-position: 100% 50%; }
            100% { background-position: 0% 50%; }
        }

        #name-picker-app h1 {
            text-align: center;
            color: #333;
            margin-bottom: 30px;
            font-size: 2.2em;
            text-shadow: 2px 2px 4px rgba(0,0,0,0.1);
        }

        .np-controls {
            display: flex;
            gap: 10px;
            margin-bottom: 30px;
            flex-wrap: wrap;
            justify-content: center;
            align-items: center;
        }

        .np-file-input-wrapper {
            position: relative;
            overflow: hidden;
            display: inline-block;
        }

        .np-file-input-wrapper input[type=file] {
            position: absolute;
            left: -9999px;
            opacity: 0;
            width: 0.1px;
            height: 0.1px;
            pointer-events: none;
        }

        .np-file-input-label {
            background: linear-gradient(45deg, #ff6b6b, #ee5a52) !important;
            color: white !important;
            padding: 12px 16px !important;
            border-radius: 25px !important;
            cursor: pointer !important;
            font-weight: bold !important;
            transition: all 0.3s ease !important;
            display: inline-block !important;
            box-shadow: 0 4px 15px rgba(0,0,0,0.2) !important;
            font-size: 14px !important;
            text-align: center !important;
            white-space: nowrap !important;
            text-decoration: none !important;
            border: none !important;
            outline: none !important;
            position: relative !important;
            z-index: 1 !important;
            min-width: 140px !important;
        }

        .np-file-input-label:hover {
            transform: translateY(-2px) !important;
            box-shadow: 0 8px 25px rgba(0,0,0,0.3) !important;
            color: white !important;
            text-decoration: none !important;
        }

        .np-file-input-label:focus {
            outline: 2px solid #4ecdc4 !important;
            outline-offset: 2px !important;
        }

        .np-file-input-label:active {
            transform: translateY(0px) !important;
        }

        .np-text-input-group {
            display: flex;
            gap: 5px;
            align-items: center;
            flex-wrap: wrap;
        }

        .np-name-input {
            padding: 12px;
            border: 2px solid #ddd;
            border-radius: 25px;
            font-size: 14px;
            width: 200px;
            height: 40px;
            resize: none;
            transition: border-color 0.3s ease;
        }

        .np-name-input:focus {
            outline: none;
            border-color: #4ecdc4;
        }

        .np-button {
            color: white;
            border: none;
            padding: 12px 16px;
            border-radius: 25px;
            font-size: 14px;
            font-weight: bold;
            cursor: pointer;
            transition: all 0.3s ease;
            box-shadow: 0 4px 15px rgba(0,0,0,0.2);
            text-decoration: none;
        }

        .np-add-button {
            background: linear-gradient(45deg, #9b59b6, #8e44ad);
        }

        .np-pick-button {
            background: linear-gradient(45deg, #4ecdc4, #44a08d);
            font-size: 16px;
            padding: 12px 20px;
        }

        .np-clear-button {
            background: linear-gradient(45deg, #e74c3c, #c0392b);
        }

        .np-button:hover:not(:disabled) {
            transform: translateY(-2px);
            box-shadow: 0 8px 25px rgba(0,0,0,0.3);
        }

        .np-button:disabled {
            opacity: 0.6;
            cursor: not-allowed;
        }

        .np-game-area {
            position: relative;
            height: 500px;
            background: #eef4f3;
            border-radius: 15px;
            overflow: hidden;
            border: 3px solid #333;
            margin: 20px 0;
        }

        .np-crane-container {
            position: absolute;
            top: 10px;
            width: 100%;
            height: 100px;
            z-index: 20;
        }

        .np-crane-track {
            position: absolute;
            top: 0;
            left: 0;
            right: 0;
            height: 8px;
            background: #666;
            border-radius: 4px;
        }

        .np-crane {
            position: absolute;
            top: 0;
            left: 50%;
            transform: translateX(-50%);
            width: 80px;
            height: 100px;
            transition: left 2s ease-in-out;
        }

        .np-crane-head {
            width: 80px;
            height: 20px;
            background: #ff6b6b;
            border-radius: 10px;
            position: relative;
            box-shadow: 0 3px 8px rgba(0,0,0,0.4);
        }

        .np-crane-cable {
            width: 5px;
            height: 180px;
            background: #333;
            margin: 0 auto;
            transition: height 1s ease-in-out;
            position: relative;
        }

        .np-crane-hook {
            width: 60px;
            height: 10px;
            background: #888;
            border-radius: 15px 15px 0 0;
            margin: 0 auto;
            position: relative;
            top: -8px;
        }

        .np-picked-ball {
            position: absolute;
            bottom: -80px;
            left: 50%;
            transform: translateX(-50%);
            width: 80px;
            height: 80px;
            border-radius: 50%;
            font-size: 12px;
            font-weight: bold;
            color: white;
            text-shadow: 1px 1px 2px rgba(0,0,0,0.5);
            display: none;
            align-items: center;
            justify-content: center;
            text-align: center;
            line-height: 1.1;
            word-wrap: break-word;
            z-index: 25;
        }

        .np-balls-container {
            position: absolute;
            bottom: 0;
            left: 0;
            right: 0;
            height: 500px;
            overflow: hidden;
        }

        .np-ball {
            position: absolute;
            width: 70px;
            height: 70px;
            border-radius: 50%;
            display: flex;
            align-items: center;
            justify-content: center;
            font-size: 11px;
            font-weight: bold;
            color: white;
            text-shadow: 1px 1px 2px rgba(0,0,0,0.8);
            box-shadow: 0 4px 8px rgba(0,0,0,0.3);
            cursor: pointer;
            transition: all 0.3s ease;
            text-align: center;
            line-height: 1;
            word-wrap: break-word;
            overflow: hidden;
            z-index: 10;
            padding: 4px;
        }

        .np-ball:hover {
            transform: scale(1.1);
        }

        .np-ball.picked {
            animation: npPickAnimation 1s ease-in-out forwards;
        }

        @keyframes npPickAnimation {
            0% { transform: scale(1); }
            50% { transform: scale(1.2); }
            100% { transform: scale(0.8); opacity: 0; }
        }

        .np-result {
            text-align: center;
            margin: 20px 0;
            padding: 20px;
            background: linear-gradient(45deg, #4ecdc4, #44a08d);
            color: white;
            border-radius: 15px;
            font-size: 20px;
            font-weight: bold;
            min-height: 50px;
            display: flex;
            align-items: center;
            justify-content: center;
            box-shadow: 0 8px 20px rgba(0,0,0,0.2);
        }

        .np-names-list {
            margin-top: 20px;
            padding: 15px;
            background: #f8f9fa;
            border-radius: 10px;
            max-height: 200px;
            overflow-y: auto;
            display: none;
        }

        .np-names-list h3 {
            margin: 0 0 10px 0;
            color: #333;
        }

        .np-names-grid {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
            gap: 5px;
        }

        .np-name-item {
            padding: 5px 10px;
            background: white;
            border-radius: 5px;
            font-size: 14px;
            text-align: center;
            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
        }

        .np-error {
            color: #ff6b6b;
            text-align: center;
            margin: 10px 0;
            font-weight: bold;
        }

        @media (max-width: 768px) {
            .np-controls {
                gap: 8px;
                flex-direction: column;
            }
            
            .np-name-input {
                width: 100%;
                max-width: 250px;
            }
            
            .np-button {
                padding: 10px 14px;
                font-size: 12px;
            }
            
            .np-game-area {
                height: 400px;
            }
            
            .np-ball {
                width: 60px;
                height: 60px;
                font-size: 10px;
            }
        }

        @media (max-width: 480px) {
            #name-picker-app {
                padding: 15px;
            }
            
            #name-picker-app h1 {
                font-size: 1.8em;
            }
            
            .np-game-area {
                height: 350px;
            }
        }
    </style>

    <h1>Random Name Picker</h1>
    
    <div class="np-controls">
        <div class="np-file-input-wrapper">
            <label for="npFileInput" class="np-file-input-label">📁 Upload File</label>
            <input type="file" id="npFileInput" accept=".csv,.xlsx,.xls" style="display: none !important;" />
        </div>
        
        <div class="np-text-input-group">
            <textarea id="npNameInput" class="np-name-input" placeholder="Enter names (one name per line)..."></textarea>
            <button class="np-button np-add-button" id="npAddButton">➕ Add Names</button>
        </div>
        
        <button class="np-button np-pick-button" id="npPickButton" disabled>🎯 Pick Random Name!</button>
        <button class="np-button np-clear-button" id="npClearButton">🗑️ Clear All</button>
    </div>

    <div class="np-game-area">
        <div class="np-crane-container">
            <div class="np-crane-track"></div>
            <div class="np-crane" id="npCrane">
                <div class="np-crane-head"></div>
                <div class="np-crane-cable" id="npCraneCable">
                    <div class="np-picked-ball" id="npPickedBall"></div>
                </div>
                <div class="np-crane-hook"></div>
            </div>
        </div>
        <div class="np-balls-container" id="npBallsContainer">
            <!-- Balls will be generated here -->
        </div>
    </div>

    <div class="np-result" id="npResult">
        Add names to get started! 🚀
    </div>

    <div class="np-names-list" id="npNamesList">
        <h3>📋 Added Names:</h3>
        <div class="np-names-grid" id="npNamesGrid"></div>
    </div>
</div>

<script type="text/javascript" src="/tools/xlsx-library.js"></script>
<script>
(function() {
    // Namespace all variables to avoid conflicts
    const NP = {
        names: [],
        balls: [],
        isAnimating: false,
        animationId: null,
        currentPickedBall: null,
        
        gradientColors: [
            'linear-gradient(45deg, #FF6B6B, #FF8E8E)',
            'linear-gradient(45deg, #4ECDC4, #45B7D1)',
            'linear-gradient(45deg, #45B7D1, #96CEB4)',
            'linear-gradient(45deg, #96CEB4, #FECA57)',
            'linear-gradient(45deg, #FECA57, #FF9FF3)',
            'linear-gradient(45deg, #FF9FF3, #54A0FF)',
            'linear-gradient(45deg, #54A0FF, #5F27CD)',
            'linear-gradient(45deg, #5F27CD, #00D2D3)',
            'linear-gradient(45deg, #FD79A8, #FDCB6E)',
            'linear-gradient(45deg, #6C5CE7, #A29BFE)',
            'linear-gradient(45deg, #00B894, #00CEC9)',
            'linear-gradient(45deg, #E17055, #FDCB6E)',
            'linear-gradient(45deg, #0984E3, #74B9FF)',
            'linear-gradient(45deg, #A29BFE, #FD79A8)',
            'linear-gradient(45deg, #00CEC9, #55A3FF)',
            'linear-gradient(45deg, #FDCB6E, #FF7675)',
            'linear-gradient(45deg, #FF7675, #6C5CE7)',
            'linear-gradient(45deg, #74B9FF, #00B894)',
            'linear-gradient(45deg, #55A3FF, #E17055)',
            'linear-gradient(45deg, #00D2D3, #FD79A8)'
        ]
    };

    // Get elements
    const elements = {
        fileInput: document.getElementById('npFileInput'),
        nameInput: document.getElementById('npNameInput'),
        addButton: document.getElementById('npAddButton'),
        pickButton: document.getElementById('npPickButton'),
        clearButton: document.getElementById('npClearButton'),
        ballsContainer: document.getElementById('npBallsContainer'),
        result: document.getElementById('npResult'),
        namesList: document.getElementById('npNamesList'),
        namesGrid: document.getElementById('npNamesGrid'),
        crane: document.getElementById('npCrane'),
        craneCable: document.getElementById('npCraneCable'),
        pickedBall: document.getElementById('npPickedBall')
    };

    // Event listeners
    elements.fileInput.addEventListener('change', handleFileUpload);
    elements.addButton.addEventListener('click', addNames);
    elements.pickButton.addEventListener('click', pickRandomName);
    elements.clearButton.addEventListener('click', clearAll);

    // Prevent the file input from showing default styling
    elements.fileInput.addEventListener('click', function(e) {
        e.stopPropagation();
    });

    // Handle label click properly
    if (elements.fileInput && elements.fileInput.previousElementSibling) {
        const label = elements.fileInput.previousElementSibling;
        label.addEventListener('click', function(e) {
            e.preventDefault();
            elements.fileInput.click();
        });
    }

    function addNames() {
        const inputText = elements.nameInput.value.trim();
        if (!inputText) return;
        
        const lines = inputText.split('\n');
        const newNames = [];
        
        lines.forEach(line => {
            const name = line.trim();
            if (name && !NP.names.includes(name)) {
                NP.names.push(name);
                newNames.push(name);
            }
        });
        
        elements.nameInput.value = '';
        updateDisplay();
        
        if (newNames.length > 0) {
            elements.result.innerHTML = `${newNames.length} new names added! Total: ${NP.names.length} names 🎲`;
        }
    }

    function clearAll() {
        NP.names = [];
        NP.balls = [];
        elements.ballsContainer.innerHTML = '';
        NP.currentPickedBall = null;
        elements.pickedBall.style.display = 'none';
        updateDisplay();
        elements.result.innerHTML = 'Add names to get started! 🚀';
    }

    function updateDisplay() {
        displayNames();
        createBalls();
        elements.pickButton.disabled = NP.names.length === 0;
    }

    function handleFileUpload(event) {
        const file = event.target.files[0];
        if (!file) return;

        elements.result.innerHTML = 'Loading file... 📂';
        
        // Reset the file input to allow selecting the same file again
        setTimeout(() => {
            elements.fileInput.value = '';
        }, 1000);
        
        const reader = new FileReader();
        reader.onload = function(e) {
            try {
                if (file.name.endsWith('.csv')) {
                    parseCSV(e.target.result);
                } else {
                    parseExcel(e.target.result);
                }
            } catch (error) {
                elements.result.innerHTML = '<span class="np-error">Error reading file!</span>';
                console.error('File parsing error:', error);
            }
        };

        reader.onerror = function() {
            elements.result.innerHTML = '<span class="np-error">Error reading file!</span>';
        };

        if (file.name.endsWith('.csv')) {
            reader.readAsText(file);
        } else {
            reader.readAsArrayBuffer(file);
        }
    }

    function parseCSV(text) {
        const lines = text.split('\n');
        const extractedNames = [];
        
        lines.forEach(line => {
            const trimmed = line.trim();
            if (trimmed && trimmed.length > 0 && !['Name', 'Names', 'name', 'names'].includes(trimmed)) {
                if (trimmed.includes(',')) {
                    const parts = trimmed.split(',');
                    parts.forEach(part => {
                        const name = part.trim().replace(/"/g, '');
                        if (name && name.length > 0) {
                            extractedNames.push(name);
                        }
                    });
                } else {
                    extractedNames.push(trimmed);
                }
            }
        });
        
        loadNames(extractedNames);
    }

    function parseExcel(arrayBuffer) {
        try {
            if (typeof XLSX === 'undefined') {
                elements.result.innerHTML = '<span class="np-error">Excel library not loaded!</span>';
                return;
            }

            const workbook = XLSX.read(arrayBuffer, { type: 'array' });
            
            if (!workbook.SheetNames || workbook.SheetNames.length === 0) {
                elements.result.innerHTML = '<span class="np-error">No sheets found in file!</span>';
                return;
            }
            
            const firstSheet = workbook.Sheets[workbook.SheetNames[0]];
            const data = XLSX.utils.sheet_to_json(firstSheet, { header: 1 });
            
            const extractedNames = [];
            data.forEach((row) => {
                if (row && Array.isArray(row) && row.length > 0) {
                    row.forEach(cell => {
                        if (cell !== null && cell !== undefined) {
                            const name = String(cell).trim();
                            if (name && name.length > 0 && !['Name', 'Names', 'name', 'names'].includes(name)) {
                                extractedNames.push(name);
                            }
                        }
                    });
                }
            });
            
            loadNames(extractedNames);
        } catch (error) {
            elements.result.innerHTML = '<span class="np-error">Error parsing Excel file!</span>';
        }
    }

    function loadNames(extractedNames) {
        if (!extractedNames || extractedNames.length === 0) {
            elements.result.innerHTML = '<span class="np-error">No names found in file!</span>';
            return;
        }

        const newNames = [...new Set(extractedNames.filter(name => name && name.trim().length > 0))];
        NP.names = [...new Set([...NP.names, ...newNames])];
        
        if (NP.names.length === 0) {
            elements.result.innerHTML = '<span class="np-error">No valid names found!</span>';
            return;
        }

        updateDisplay();
        elements.result.innerHTML = `Ready! ${NP.names.length} names loaded 🎲`;
    }

    function displayNames() {
        if (NP.names.length === 0) {
            elements.namesList.style.display = 'none';
            return;
        }

        elements.namesGrid.innerHTML = '';
        NP.names.forEach(name => {
            const nameItem = document.createElement('div');
            nameItem.className = 'np-name-item';
            nameItem.textContent = name;
            elements.namesGrid.appendChild(nameItem);
        });
        elements.namesList.style.display = 'block';
    }

    function createBalls() {
        elements.ballsContainer.innerHTML = '';
        NP.balls = [];
        
        if (NP.names.length === 0) return;
        
        const containerWidth = elements.ballsContainer.offsetWidth || 400;
        
        NP.names.forEach((name, index) => {
            const ball = document.createElement('div');
            ball.className = 'np-ball';
            ball.textContent = name;
            ball.style.background = NP.gradientColors[index % NP.gradientColors.length];
            
            const maxBallsPerRow = Math.floor(containerWidth / 75);
            const row = Math.floor(index / maxBallsPerRow);
            const col = index % maxBallsPerRow;
            
            const startX = Math.max(5, Math.min((col * 75) + Math.random() * 15, containerWidth - 75));
            const startY = -80 - (row * 80);
            
            ball.style.left = startX + 'px';
            ball.style.top = startY + 'px';
            ball.style.position = 'absolute';
            
            elements.ballsContainer.appendChild(ball);
            
            const ballData = {
                element: ball,
                x: startX,
                y: startY,
                vx: (Math.random() - 0.5) * 0.1,
                vy: 0,
                name: name,
                bounce: 0.2,
                friction: 0.95
            };
            
            NP.balls.push(ballData);
        });
        
        if (NP.balls.length > 0) {
            startPhysics();
        }
    }

    function startPhysics() {
        if (NP.animationId) cancelAnimationFrame(NP.animationId);
        
        function animate() {
            const containerHeight = elements.ballsContainer.offsetHeight || 400;
            const containerWidth = elements.ballsContainer.offsetWidth || 400;
            const gravity = 0.2;
            const ballRadius = 35;
            
            NP.balls.forEach((ball, index) => {
                if (Math.abs(ball.vy) > 0.05 || ball.y < containerHeight - 70) {
                    ball.vy += gravity;
                }
                
                ball.vy = Math.max(-15, Math.min(15, ball.vy));
                ball.vx = Math.max(-8, Math.min(8, ball.vx));
                
                ball.x += ball.vx;
                ball.y += ball.vy;
                
                // Ball collisions
                NP.balls.forEach((otherBall, otherIndex) => {
                    if (index !== otherIndex) {
                        const dx = ball.x - otherBall.x;
                        const dy = ball.y - otherBall.y;
                        const distance = Math.sqrt(dx * dx + dy * dy);
                        const minDistance = ballRadius * 2;
                        
                        if (distance < minDistance && distance > 0) {
                            const overlap = minDistance - distance;
                            const separationX = (dx / distance) * overlap * 0.5;
                            const separationY = (dy / distance) * overlap * 0.5;
                            
                            ball.x += separationX;
                            ball.y += separationY;
                            otherBall.x -= separationX;
                            otherBall.y -= separationY;
                            
                            const normalX = dx / distance;
                            const normalY = dy / distance;
                            const relativeVelocityX = ball.vx - otherBall.vx;
                            const relativeVelocityY = ball.vy - otherBall.vy;
                            const velocityAlongNormal = relativeVelocityX * normalX + relativeVelocityY * normalY;
                            
                            if (velocityAlongNormal > 0) return;
                            
                            const restitution = 0.4;
                            const impulse = -(1 + restitution) * velocityAlongNormal;
                            
                            ball.vx += impulse * normalX * 0.4;
                            ball.vy += impulse * normalY * 0.4;
                            otherBall.vx -= impulse * normalX * 0.4;
                            otherBall.vy -= impulse * normalY * 0.4;
                        }
                    }
                });
                
                // Ground collision
                if (ball.y >= containerHeight - 70) {
                    ball.y = containerHeight - 70;
                    ball.vy *= -0.5;
                    ball.vx *= 0.9;
                    
                    if (Math.abs(ball.vy) < 1.5) {
                        ball.vy = 0;
                    }
                }
                
                // Wall collisions
                if (ball.x <= 0) {
                    ball.x = 0;
                    ball.vx *= -0.6;
                } else if (ball.x >= containerWidth - 70) {
                    ball.x = containerWidth - 70;
                    ball.vx *= -0.6;
                }
                
                ball.vx *= 0.998;
                ball.vy *= 0.998;
                
                ball.element.style.left = ball.x + 'px';
                ball.element.style.top = ball.y + 'px';
            });
            
            NP.animationId = requestAnimationFrame(animate);
        }
        
        animate();
    }

    function pickRandomName() {
        if (NP.isAnimating || NP.names.length === 0) return;
        
        NP.isAnimating = true;
        elements.pickButton.disabled = true;
        elements.result.innerHTML = 'Picking... 🎯';
        
        const randomIndex = Math.floor(Math.random() * NP.names.length);
        const pickedName = NP.names[randomIndex];
        let pickedBallData = null;
        
        NP.balls.forEach(ball => {
            if (ball.name === pickedName) {
                pickedBallData = ball;
            }
        });
        
        if (pickedBallData) {
            const ballCenterX = pickedBallData.x + 35;
            const containerWidth = elements.ballsContainer.offsetWidth || 400;
            const craneNewPosition = Math.min(Math.max((ballCenterX / containerWidth) * 100, 10), 90);
            
            elements.crane.style.left = craneNewPosition + '%';
            
            setTimeout(() => {
                elements.craneCable.style.height = '280px';
                
                setTimeout(() => {
                    elements.pickedBall.textContent = pickedName;
                    elements.pickedBall.style.background = pickedBallData.element.style.background;
                    elements.pickedBall.style.display = 'flex';
                    NP.currentPickedBall = pickedName;
                    
                    pickedBallData.element.classList.add('picked');
                    
                    setTimeout(() => {
                        elements.result.innerHTML = `🎉 <strong>${pickedName}</strong> 🎉`;
                        
                        setTimeout(() => {
                            elements.craneCable.style.height = '180px';
                            elements.crane.style.left = '50%';
                            
                            const ballIndex = NP.balls.findIndex(b => b.name === pickedName);
                            if (ballIndex !== -1) {
                                NP.balls.splice(ballIndex, 1);
                                pickedBallData.element.remove();
                            }
                            
                            NP.names.splice(randomIndex, 1);
                            displayNames();
                            
                            if (NP.names.length === 0) {
                                elements.result.innerHTML = 'All names have been picked! Add new names to continue 🎊';
                                elements.pickButton.disabled = true;
                            } else {
                                elements.pickButton.disabled = false;
                            }
                            
                            NP.isAnimating = false;
                        }, 2000);
                    }, 1000);
                }, 1000);
            }, 1500);
        }
    }

    // Initialize when DOM is ready
    function init() {
        if (document.getElementById('name-picker-app')) {
            elements.result.innerHTML = 'Add names to get started! 🚀';
            console.log('Name Picker initialized successfully');
        }
    }

    // Wait for DOM to be ready
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', init);
    } else {
        init();
    }

})();
</script>