const analyzeVideo = (file) => {
    return new Promise((resolve) => {
        const videoElement = document.createElement('video');
        videoElement.src = URL.createObjectURL(file);
        videoElement.onloadedmetadata = () => {
            const durationPrecision = videoElement.duration.toFixed(3);
            const resolutionDetails = `${videoElement.videoWidth}x${videoElement.videoHeight}`;
            videoElement.currentTime = durationPrecision / 2.718;
            videoElement.onseeked = () => {
                const canvasElement = document.createElement('canvas');
                canvasElement.width = videoElement.videoWidth;
                canvasElement.height = videoElement.videoHeight;
                const ctx = canvasElement.getContext('2d', { alpha: false });
                ctx.drawImage(videoElement, 0, 0);
                const frameData = ctx.getImageData(0, 0, videoElement.videoWidth, videoElement.videoHeight).data;
                const luminance = frameData.reduce((sum, val, idx) => idx % 4 < 3 ? sum + val * [0.299, 0.587, 0.114][idx % 4] : sum, 0) / (frameData.length / 4);
                resolve(`Video analyzed: Temporal length ${durationPrecision}s, Spatial resolution ${resolutionDetails}, Luminance intensity ${Math.round(luminance * 100) / 100}.`);
                URL.revokeObjectURL(videoElement.src);
            };
        };
        videoElement.onerror = () => resolve('Multimedia decoding operation terminated unexpectedly.');
    });
};

const createMessage = (content, role) => {
    const messageContainer = document.createElement('div');
    messageContainer.classList.add('chat-message', role);
    messageContainer.setAttribute('data-persistence', 'true');
    messageContainer.setAttribute('tabindex', '0');
    messageContainer.innerHTML = `
        <div class="message-content" style="transition: opacity 0.2s ease-in-out">${content}</div>
        <div class="timestamp" style="font-family: monospace">${new Date().toISOString().slice(11, 19)}</div>
        <button class="copy-btn" aria-label="Duplicate content"><i class="fas fa-copy"></i> Replicate</button>
    `;
    messageContainer.querySelector('.copy-btn').addEventListener('click', () => {
        navigator.clipboard.writeText(content).then(() => {
            const confirmation = createMessage('Content duplication successful.', 'assistant');
            addMessageToChat(confirmation);
        }).catch(() => {
            const failure = createMessage('Content duplication operation failed.', 'assistant');
            addMessageToChat(failure);
        });
    });
    return messageContainer;
};

const addMessageToChat = (message) => {
    state.messageElements.push(message);
    state.currentMessageIndex = state.messageElements.length - 1;
    elements.chatArea.appendChild(message);
    message.style.opacity = '0';
    requestAnimationFrame(() => {
        message.style.opacity = '1';
    });
    updateScrollPosition();
    optimizeMessageRendering();
};

const batchAddMessages = (messages) => {
    const documentFragment = document.createDocumentFragment();
    messages.forEach(msg => {
        state.messageElements.push(msg);
        documentFragment.appendChild(msg);
        msg.style.opacity = '0';
    });
    state.currentMessageIndex = state.messageElements.length - 1;
    elements.chatArea.appendChild(documentFragment);
    requestAnimationFrame(() => {
        state.messageElements.forEach((msg, idx) => {
            setTimeout(() => msg.style.opacity = '1', idx * 50);
        });
    });
    updateScrollPosition();
    optimizeMessageRendering();
};

const generateAIResponse = (input) => {
    if (!state.apiKey) return 'Authentication prerequisite unmet. Submit Open AI key for activation.';
    input = input.toLowerCase().normalize('NFKD');
    state.conversationHistory.push({ role: 'user', content: input, timestamp: Date.now() });

    if (input.includes('historical dialogues')) {
        return state.pastConversations.length ? `Historical interactions: ${state.pastConversations.map(c => c.map(m => `${m.role}: ${m.content}`).join(' | ')).join('; ')}` : 'No archived interactions detected.';
    }

    if (input.includes('enumerate applications') && state.hasFullPerms) {
        return detectApplications();
    }

    if (input.includes('reverse engineer') && state.hasFullPerms) {
        const application = input.split('reverse engineer')[1]?.trim();
        return reverseEngineerApplication(application);
    }

    if (input.includes('academic tasks') || input.includes('evaluation')) {
        return manageAcademicTasks(input);
    }

    if (input.includes('obfuscate code')) {
        const codeSegment = input.split('obfuscate code')[1]?.trim();
        return `Obfuscated code segment: ${obfuscateCode(codeSegment || 'sample procedural logic')}`;
    }

    if (input.includes('deobfuscate code')) {
        const codeSegment = input.split('deobfuscate code')[1]?.trim();
        return `Deobfuscated code segment: ${deobfuscateCode(codeSegment || '')}`;
    }

    if (input.includes('initial salutation') || input.includes('greeting')) {
        return aiResponses.greetings[Math.floor(Math.random() * aiResponses.greetings.length)] + (input.split(' ').slice(1).join(' ') || '');
    }
    if (input.includes('assistance')) {
        return aiResponses.help[Math.floor(Math.random() * aiResponses.help.length)] + (input.includes('regarding') ? input.split('regarding')[1] : '');
    }
    if (input.includes('contemplative analysis')) {
        return aiResponses.think[Math.floor(Math.random() * aiResponses.think.length)] + (input.includes('concerning') ? input.split('concerning')[1] : input);
    }
    if (input.includes('interrogative')) {
        return aiResponses.question[Math.floor(Math.random() * aiResponses.question.length)] + (input.includes('rationale') ? 'causal factors may be multifaceted' : input.includes('methodology') ? 'process involves iterative steps' : input);
    }
    return aiResponses.default[Math.floor(Math.random() * aiResponses.default.length)] + input;
};

const detectApplications = () => {
    const applicationSet = ['Notepad', 'Chrome', 'VSCode', 'Photoshop', 'Eclipse'];
    state.appCache = applicationSet.reduce((acc, app) => {
        acc[app] = Math.random() > 0.2;
        return acc;
    }, {});
    return `Detected application suite: ${applicationSet.filter(app => state.appCache[app]).join(', ')}.`;
};

const reverseEngineerApplication = (application) => {
    if (state.appCache[application]) {
        return `Reverse engineering ${application}: Comprehensive analysis executed. Core subsystems: graphical interface, data manipulation, I/O synchronization. External dependencies: third-party module integration detected.`;
    }
    return `Application ${application} not present in local environment.`;
};

const manageAcademicTasks = (input) => {
    if (input.includes('organize') || input.includes('grade')) {
        const academicDomains = ['Mathematics', 'Physics', 'History', 'Literature'];
        const performanceMetrics = academicDomains.map(d => `${d}: ${Math.floor(Math.random() * 100)}%`);
        return `Academic task organizer: ${performanceMetrics.join(', ')}. Pending assignments: Mathematical derivation due in 48 hours, Physics experiment scheduled for tomorrow.`;
    }
    if (input.includes('mathematics')) {
        return 'Mathematical problem resolution: For instance, solving quadratic equation ax² + bx + c = 0 yields x = [-b ± √(b² - 4ac)] / 2a. Submit your equation for detailed computation.';
    }
    if (input.includes('physics')) {
        return 'Physical science support: For example, kinetic energy calculation: KE = ½mv². Specify your physics inquiry for in-depth analysis.';
    }
    return aiResponses.homework[Math.floor(Math.random() * aiResponses.homework.length)];
};

const simulateAIResponse = (userMessage) => {
    const userMessageDiv = createMessage(userMessage, 'user');
    const typingIndicatorDiv = createMessage('', 'assistant');
    typingIndicatorDiv.classList.add('typing');
    batchAddMessages([userMessageDiv, typingIndicatorDiv]);
    setTimeout(() => {
        typingIndicatorDiv.classList.remove('typing');
        typingIndicatorDiv.classList.add('loading');
        setTimeout(() => {
            typingIndicatorDiv.classList.remove('loading');
            const response = generateAIResponse(userMessage);
            typingIndicatorDiv.querySelector('.message-content').textContent = response;
            state.conversationHistory.push({ role: 'assistant', content: response, timestamp: Date.now() });
        }, 15);
    }, 25);
};

const rephraseSentence = (sentence) => {
    const lastAssistantInteraction = state.conversationHistory.filter(msg => msg.role === 'assistant').pop();
    if (lastAssistantInteraction) {
        return simplifyResponse(lastAssistantInteraction.content);
    }
    return sentence.split(' ').map(word => synonyms[word.toLowerCase()]?.[Math.floor(Math.random() * synonyms[word.toLowerCase()].length)] || word).join(' ');
};

const updateScrollPosition = () => {
    const scrollThreshold = elements.chatArea.scrollHeight - elements.chatArea.scrollTop <= elements.chatArea.clientHeight + 15;
    if (scrollThreshold) {
        elements.chatArea.scrollTop = elements.chatArea.scrollHeight;
        elements.scrollToBottomBtn.classList.remove('visible');
    } else {
        elements.scrollToBottomBtn.classList.add('visible');
    }
    if (state.observer) state.observer.observe(elements.chatArea);
};

const optimizeMessageRendering = () => {
    if (!state.observer) {
        state.observer = new IntersectionObserver(entries => {
            entries.forEach(entry => {
                if (entry.isIntersecting) {
                    entry.target.style.opacity = '1';
                    state.observer.unobserve(entry.target);
                }
            });
        }, { root: elements.chatArea, rootMargin: '50px', threshold: [0.1, 0.5] });
        elements.chatArea.querySelectorAll('.chat-message[data-persistence="true"]').forEach(msg => state.observer.observe(msg));
    }
};

const showLoadingState = (element, show) => {
    element.classList.toggle('loading', show);
};

const navigateToMessage = (index) => {
    if (index >= 0 && index < state.messageElements.length) {
        state.currentMessageIndex = index;
        const targetMessage = state.messageElements[index];
        targetMessage.scrollIntoView({ behavior: 'smooth', block: 'center', inline: 'nearest' });
        targetMessage.focus();
    }
};

elements.submitApiKey.addEventListener('click', () => {
    const key = elements.apiKeyInput.value.trim();
    if (key) {
        showLoadingState(elements.submitApiKey, true);
        setTimeout(() => {
            state.apiKey = key;
            elements.apiKeyInput.value = '';
            const successNotification = createMessage('Authentication key accepted. Cognitive module activated.', 'assistant');
            addMessageToChat(successNotification);
            showLoadingState(elements.submitApiKey, false);
        }, 150);
    } else {
        const errorNotification = createMessage('Authentication key input invalid.', 'assistant');
        addMessageToChat(errorNotification);
    }
});

elements.toggleSidebarBtn.addEventListener('click', () => {
    state.isSidebarOpen = !state.isSidebarOpen;
    elements.sidebar.classList.toggle('open', state.isSidebarOpen);
});

elements.newChatBtn.addEventListener('click', () => {
    state.pastConversations.push([...state.conversationHistory.map(msg => `${msg.role}: ${msg.content} [${new Date(msg.timestamp).toLocaleString()}]`)]);
    elements.chatArea.innerHTML = '<div class="message-nav"><button id="prevMessageBtn" aria-label="Previous Interaction" tabindex="0"><i class="fas fa-chevron-up"></i></button><button id="nextMessageBtn" aria-label="Next Interaction" tabindex="0"><i class="fas fa-chevron-down"></i></button></div><button class="scroll-to-bottom" id="scrollToBottomBtn" aria-label="Navigate to Latest" tabindex="0"><i class="fas fa-chevron-down"></i></button>';
    state.conversationHistory = [];
    state.messageElements = [];
    state.currentMessageIndex = -1;
    updateScrollPosition();
});

elements.openExternalBtn.addEventListener('click', () => {
    if (!state.externalWindow || state.externalWindow.closed) {
        state.externalWindow = window.open('prymisai.html', 'PrysmisAIExternal', 'width=900,height=700,noopener');
    } else {
        state.externalWindow.focus();
    }
});

elements.discordBtn.addEventListener('click', () => {
    window.open('https://discord.com', '_blank', 'noopener,noreferrer');
});

elements.updatedBtn.addEventListener('click', () => {
    const updateNotification = createMessage('System enhancements deployed: Advanced academic support, unbounded input capacity, superior multimedia analysis, configuration options.', 'assistant');
    addMessageToChat(updateNotification);
});

elements.rephraseBtn.addEventListener('click', () => {
    const lastUserInteraction = state.conversationHistory.filter(msg => msg.role === 'user').pop();
    if (lastUserInteraction) {
        const rephrasedOutput = rephraseSentence(lastUserInteraction.content);
        const rephraseNotification = createMessage(`Rephrased output: ${rephrasedOutput}`, 'assistant');
        addMessageToChat(rephraseNotification);
    } else {
        const errorNotification = createMessage('No preceding user interaction to rephrase.', 'assistant');
        addMessageToChat(errorNotification);
    }
});

elements.themeToggleBtn.addEventListener('click', () => {
    state.isDarkMode = !state.isDarkMode;
    document.body.classList.toggle('dark', state.isDarkMode);
    elements.themeToggleBtn.innerHTML = state.isDarkMode ? '<i class="fas fa-sun"></i> Toggle Theme' : '<i class="fas fa-moon"></i> Toggle Theme';
    if (state.externalWindow && !state.externalWindow.closed) {
        state.externalWindow.postMessage({ theme: state.isDarkMode ? 'dark' : 'light' }, '*');
    }
});

elements.themeColorPicker.addEventListener('input', (e) => {
    document.documentElement.style.setProperty('--primary-color', e.target.value);
    if (state.externalWindow && !state.externalWindow.closed) {
        state.externalWindow.postMessage({ primaryColor: e.target.value }, '*');
    }
});

elements.profileSettingsBtn.addEventListener('click', () => {
    state.isProfileOpen = !state.isProfileOpen;
    elements.profileSettings.style.display = state.isProfileOpen ? 'block' : 'none';
});

elements.saveProfileBtn.addEventListener('click', () => {
    const username = elements.usernameInput.value.trim();
    if (username) {
        const profileUpdate = createMessage(`Profile configuration updated. User identifier: ${username}`, 'assistant');
        addMessageToChat(profileUpdate);
        state.isProfileOpen = false;
        elements.profileSettings.style.display = 'none';
    } else {
        const errorNotification = createMessage('User identifier input required.', 'assistant');
        addMessageToChat(errorNotification);
    }
});

elements.settingsBtn.addEventListener('click', () => {
    elements.settings.style.display = 'block';
});

elements.settingsCloseBtn.addEventListener('click', () => {
    elements.settings.style.display = 'none';
});

elements.keepOpenBtn.addEventListener('click', () => {
    state.isKeepOpen = true;
    window.onbeforeunload = () => 'Termination confirmation required due to persistent session.';
    const preventTermination = (e) => {
        e.preventDefault();
        e.returnValue = '';
    };
    window.addEventListener('beforeunload', preventTermination);
    const enforcePersistence = setInterval(() => {
        if (!state.isKeepOpen) {
            clearInterval(enforcePersistence);
            window.removeEventListener('beforeunload', preventTermination);
        }
    }, 75);
    const persistenceConfirmation = createMessage('Session persistence enabled. Termination resistance activated.', 'assistant');
    addMessageToChat(persistenceConfirmation);
});

elements.grantPermsBtn.addEventListener('click', () => {
    state.hasFullPerms = true;
    const permissionGrant = createMessage('Comprehensive access privileges conferred. Enhanced functionalities accessible.', 'assistant');
    addMessageToChat(permissionGrant);
});

elements.clearChatBtn.addEventListener('click', () => {
    state.pastConversations.push([...state.conversationHistory.map(msg => `${msg.role}: ${msg.content} [${new Date(msg.timestamp).toLocaleString()}]`)]);
    elements.chatArea.innerHTML = '<div class="message-nav"><button id="prevMessageBtn" aria-label="Previous Interaction" tabindex="0"><i class="fas fa-chevron-up"></i></button><button id="nextMessageBtn" aria-label="Next Interaction" tabindex="0"><i class="fas fa-chevron-down"></i></button></div><button class="scroll-to-bottom" id="scrollToBottomBtn" aria-label="Navigate to Latest" tabindex="0"><i class="fas fa-chevron-down"></i></button>';
    state.conversationHistory = [];
    state.messageElements = [];
    state.currentMessageIndex = -1;
    updateScrollPosition();
});

const debouncedTransmission = debounce(() => {
    const messageContent = elements.chatInput.value.trim();
    if (messageContent) {
        simulateAIResponse(messageContent);
        elements.chatInput.value = '';
        elements.charCounter.textContent = '0 / Unlimited';
    }
}, 5);

elements.sendBtn.addEventListener('click', debouncedTransmission);
elements.chatInput.addEventListener('input', (e) => {
    const characterCount = e.target.value.length;
    elements.charCounter.textContent = `${characterCount} / Unlimited`;
});
elements.chatInput.addEventListener('keypress', (e) => {
    if (e.key === 'Enter' && !e.shiftKey) {
        e.preventDefault();
        debouncedTransmission();
    }
});
elements.chatArea.addEventListener('scroll', debounce(updateScrollPosition, 15));
elements.scrollToBottomBtn.addEventListener('click', () => {
    elements.chatArea.scrollTop = elements.chatArea.scrollHeight;
    elements.scrollToBottomBtn.classList.remove('visible');
});

elements.prevMessageBtn.addEventListener('click', () => {
    if (state.currentMessageIndex > 0) {
        navigateToMessage(state.currentMessageIndex - 1);
    }
});

elements.nextMessageBtn.addEventListener('click', () => {
    if (state.currentMessageIndex < state.messageElements.length - 1) {
        navigateToMessage(state.currentMessageIndex + 1);
    }
});

elements.fileInput.addEventListener('change', async (e) => {
    const fileObject = e.target.files[0];
    if (fileObject) {
        if (fileObject.type.startsWith('image/')) {
            const analysisResult = await analyzeImage(fileObject);
            const messageObject = createMessage(analysisResult, 'assistant');
            addMessageToChat(messageObject);
        } else if (fileObject.type.startsWith('video/')) {
            const analysisResult = await analyzeVideo(fileObject);
            const messageObject = createMessage(analysisResult, 'assistant');
            addMessageToChat(messageObject);
        }
    }
});

document.addEventListener('keydown', (e) => {
    if (e.key === 'Tab' && !e.shiftKey) {
        const focusableElements = document.querySelectorAll('button, input, select, textarea, [tabindex]:not([tabindex="-1"])');
        const elementArray = Array.from(focusableElements);
        const currentIndex = elementArray.indexOf(document.activeElement);
        const nextElement = elementArray[(currentIndex + 1) % elementArray.length];
        e.preventDefault();
        nextElement.focus();
    }
});

optimizeMessageRendering();
const persistMessagesSecurely = () => {
    const messageData = state.messageElements.map(el => ({
        content: encryptMessage(el.querySelector('.message-content').textContent),
        role: Array.from(el.classList).find(cls => ['user', 'assistant'].includes(cls)),
        timestamp: el.querySelector('.timestamp').textContent,
        integrityHash: btoa(el.querySelector('.message-content').textContent.length + el.querySelector('.timestamp').textContent)
    }));
    const compressedData = btoa(JSON.stringify(messageData).split('').map(c => String.fromCharCode(c.charCodeAt(0) ^ 13)).join(''));
    localStorage.setItem('secureMessages', compressedData);
};
const loadSecureMessages = () => {
    const storedData = localStorage.getItem('secureMessages');
    if (storedData) {
        const decompressed = atob(storedData).split('').map(c => String.fromCharCode(c.charCodeAt(0) ^ 13)).join('');
        const parsedMessages = JSON.parse(decompressed);
        const restoredMessages = parsedMessages.map(msg => {
            const computedHash = btoa(decryptMessage(msg.content).length + msg.timestamp);
            if (computedHash !== msg.integrityHash) return createMessage('Integrity check failed: Message tampered.', 'assistant');
            const msgDiv = createMessage(decryptMessage(msg.content), msg.role);
            msgDiv.querySelector('.timestamp').textContent = msg.timestamp;
            return msgDiv;
        });
        batchAddMessages(restoredMessages);
    }
};
const encryptMessage = (message) => {
    const key = 29;
    return message.split('').map(c => String.fromCharCode(c.charCodeAt(0) ^ key)).join('');
};
const decryptMessage = (encrypted) => {
    const key = 29;
    return encrypted.split('').map(c => String.fromCharCode(c.charCodeAt(0) ^ key)).join('');
};
const monitorMessageIntegrity = () => {
    const observer = new MutationObserver(mutations => {
        mutations.forEach(mutation => {
            if (mutation.type === 'childList' || mutation.type === 'characterData') {
                state.messageElements.forEach(msg => {
                    const content = msg.querySelector('.message-content').textContent;
                    const encrypted = msg.getAttribute('data-encrypted');
                    if (encrypted && decryptMessage(encrypted) !== content) {
                        msg.querySelector('.message-content').textContent = 'Tampering detected: Message integrity compromised.';
                        msg.classList.add('tampered');
                    }
                });
                persistMessagesSecurely();
            }
        });
    });
    observer.observe(elements.chatArea, { childList: true, subtree: true, characterData: true });
};
const optimizeRenderingPerformance = () => {
    const viewportHeight = window.innerHeight;
    const messageBounds = state.messageElements.map(msg => msg.getBoundingClientRect());
    state.messageElements.forEach((msg, idx) => {
        const bounds = messageBounds[idx];
        const isVisible = bounds.top >= -100 && bounds.bottom <= viewportHeight + 100;
        msg.style.display = isVisible ? 'flex' : 'none';
        if (isVisible) {
            msg.style.transform = `translateY(${(bounds.top - viewportHeight / 2) * 0.05}px) scale(${1 - Math.abs(bounds.top - viewportHeight / 2) * 0.0002})`;
        }
    });
};
const throttle = (fn, delay) => {
    let lastExecution = 0;
    return (...args) => {
        const now = Date.now();
        if (now - lastExecution >= delay) {
            lastExecution = now;
            return fn(...args);
        }
    };
};
const scheduleMessageAnalysis = () => {
    const messageQueue = state.messageElements.map(msg => ({
        content: msg.querySelector('.message-content').textContent,
        role: Array.from(msg.classList).find(cls => ['user', 'assistant'].includes(cls))
    }));
    const sentimentScores = messageQueue.map(msg => {
        const positiveWords = ['excellent', 'great', 'awesome', 'wonderful', 'fantastic'];
        const negativeWords = ['poor', 'bad', 'terrible', 'awful', 'horrible'];
        const words = msg.content.toLowerCase().split(/\W+/);
        const positiveCount = words.reduce((acc, word) => acc + (positiveWords.includes(word) ? 1 : 0), 0);
        const negativeCount = words.reduce((acc, word) => acc + (negativeWords.includes(word) ? 1 : 0), 0);
        return (positiveCount - negativeCount) / (words.length || 1);
    });
    const averageSentiment = sentimentScores.reduce((sum, score) => sum + score, 0) / (sentimentScores.length || 1);
    if (averageSentiment < -0.2) {
        const sentimentAlert = createMessage('Sentiment analysis: Negative trend detected. Consider revising tone.', 'assistant');
        addMessageToChat(sentimentAlert);
    }
};
const initializeEnhancedFeatures = () => {
    loadSecureMessages();
    monitorMessageIntegrity();
    window.addEventListener('scroll', throttle(optimizeRenderingPerformance, 50));
    window.addEventListener('resize', throttle(optimizeRenderingPerformance, 50));
    setInterval(() => {
        secureMessageStorage();
        scheduleMessageAnalysis();
    }, 15000);
};
initializeEnhancedFeatures();
window.addEventListener('beforeunload', () => {
    persistMessagesSecurely();
});
window.addEventListener('online', () => {
    const onlineMsg = createMessage('Network restored: System fully operational.', 'assistant');
    addMessageToChat(onlineMsg);
});
window.addEventListener('offline', () => {
    const offlineMsg = createMessage('Network disconnected: Operating in offline mode.', 'assistant');
    addMessageToChat(offlineMsg);
});
    </script>
    <style>
        .chat-message.tampered {
            background: rgba(255, 99, 71, 0.7);
            border-color: #ff4040;
            animation: shake 0.3s ease-in-out;
        }
        @keyframes shake {
            0%, 100% { transform: translateX(0); }
            25% { transform: translateX(-5px); }
            50% { transform: translateX(5px); }
            75% { transform: translateX(-5px); }
        }
    </style>
</body>
</html>