script.js

// Enhanced JavaScript for DeepChat Pro
console.log('DeepChat Pro - Advanced AI Assistant Loaded');

// Initialize enhanced tooltips and interactions
document.addEventListener('DOMContentLoaded', function() {
    // Enhanced icon tooltips
    const icons = document.querySelectorAll('[data-feather]');
    icons.forEach(icon => {
        const iconName = icon.getAttribute('data-feather');
        icon.setAttribute('title', iconName.charAt(0).toUpperCase() + iconName.slice(1));
        icon.setAttribute('aria-label', iconName);
    });

    // Initialize keyboard shortcuts
    initializeKeyboardShortcuts();
    
    // Initialize real-time capabilities indicator
    initializeCapabilitiesIndicator();
    
    // Initialize performance monitoring
    initializePerformanceMonitor();
});

// Keyboard Shortcuts
function initializeKeyboardShortcuts() {
    document.addEventListener('keydown', function(e) {
        // Ctrl + / for focus on input
        if (e.ctrlKey && e.key === '/') {
            e.preventDefault();
            const input = document.getElementById('message-input');
            if (input) input.focus();
        }
        
        // Escape to clear input
        if (e.key === 'Escape') {
            const input = document.getElementById('message-input');
            if (input) input.value = '';
        }
        
        // Enter to send (with Ctrl for new line)
        if (e.key === 'Enter' && !e.ctrlKey) {
            const input = document.getElementById('message-input');
            if (input && input === document.activeElement && input.value.trim()) {
                document.getElementById('chat-form').dispatchEvent(new Event('submit'));
            }
        }
    });
}

// Real-time Capabilities Indicator
function initializeCapabilitiesIndicator() {
    const capabilities = [
        'Analyzing real-time data...',
        'Searching academic databases...',
        'Processing natural language...',
        'Generating insights...',
        'Cross-referencing sources...'
    ];
    
    let currentCapability = 0;
    
    setInterval(() => {
        const indicator = document.querySelector('.capability-indicator');
        if (indicator) {
            indicator.style.opacity = '0';
            setTimeout(() => {
                indicator.textContent = capabilities[currentCapability];
                indicator.style.opacity = '1';
                currentCapability = (currentCapability + 1) % capabilities.length;
            }, 300);
        }
    }, 3000);
}

// Performance Monitoring
function initializePerformanceMonitor() {
    const startTime = performance.now();
    
    window.addEventListener('load', () => {
        const loadTime = performance.now() - startTime;
        console.log(`DeepChat Pro loaded in ${loadTime.toFixed(2)}ms`);
        
        // Send performance metrics (in a real app, this would go to analytics)
        if (loadTime < 1000) {
            console.log('🚀 Excellent performance!');
        }
    });
}

// Enhanced Message Management
class MessageManager {
    constructor() {
        this.messages = [];
        this.maxMessages = 100; // Prevent memory issues
    }
    
    addMessage(content, sender, type = 'text') {
        const message = {
            id: Date.now(),
            content,
            sender,
            type,
            timestamp: new Date().toISOString(),
            metadata: {}
        };
        
        this.messages.push(message);
        
        // Keep only the last maxMessages
        if (this.messages.length > this.maxMessages) {
            this.messages = this.messages.slice(-this.maxMessages);
        }
        
        return message;
    }
    
    getConversationHistory() {
        return this.messages.slice(-10); // Last 10 messages for context
    }
    
    clearMessages() {
        this.messages = [];
    }
}

// Initialize message manager
const messageManager = new MessageManager();

// Enhanced API Integration (simulated for now)
class AIClient {
    constructor() {
        this.baseURL = 'https://api.deepchat.pro/v1';
        this.isOnline = true;
    }
    
    async sendMessage(message, context = []) {
        // Simulate API call with enhanced capabilities
        return new Promise((resolve) => {
            setTimeout(() => {
                const responses = this.generateEnhancedResponse(message, context);
                resolve(responses);
            }, 1500 + Math.random() * 1000); // Simulate network delay
        });
    }
    
    generateEnhancedResponse(message, context) {
        // Enhanced response generation simulation
        const responseTypes = [
            {
                type: 'analysis',
                content: `I've analyzed "${message}" across multiple dimensions...`,
                confidence: 0.92
            },
            {
                type: 'insight',
                content: `Key insight: This topic shows strong correlation with recent developments in AI research.`,
                confidence: 0.88
            },
            {
                type: 'recommendation',
                content: `Based on my analysis, I recommend exploring these 3 areas for deeper understanding.`,
                confidence: 0.85
            }
        ];
        
        return responseTypes;
    }
}

// Initialize AI Client
const aiClient = new AIClient();

// Utility Functions
const Utils = {
    // Format timestamps
    formatTime: (date) => {
        return new Date(date).toLocaleTimeString('en-US', {
            hour12: true,
            hour: 'numeric',
            minute: '2-digit'
        });
    },
    
    // Truncate long text
    truncate: (text, length = 100) => {
        return text.length > length ? text.substring(0, length) + '...' : text;
    },
    
    // Copy to clipboard
    copyToClipboard: async (text) => {
        try {
            await navigator.clipboard.writeText(text);
            return true;
        } catch (err) {
            console.error('Failed to copy text: ', err);
            return false;
        }
    },
    
    // Download content
    downloadContent: (content, filename) => {
        const blob = new Blob([content], { type: 'text/plain' });
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');
        a.href = url;
        a.download = filename;
        a.click();
        URL.revokeObjectURL(url);
    }
};

// Export for global access
window.DeepChatPro = {
    messageManager,
    aiClient,
    Utils,
    version: '2.0.0'
};