Upload 10 files

README.md

@@ -1,12 +1,229 @@
----
-title: EnglishStudyHelper
-emoji: 🏆
-colorFrom: blue
-colorTo: blue
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
+# 🎓 English Helper - Advanced AI Language Learning Platform
+
+## 🌟 Visão Geral
+
+O English Helper é uma plataforma avançada de aprendizado de inglês que combina inteligência artificial, curadoria de conteúdo personalizada, e planejamento de estudos inteligente para oferecer uma experiência de aprendizado imersiva e personalizada.
+
+## 🚀 Funcionalidades Principais
+
+### 1. 🤖 Motor de Curadoria de Conteúdo Personalizado
+- **Busca Inteligente**: Encontre artigos e conteúdos relevantes baseados em seus interesses
+- **Análise de Conteúdo com IA**: Avaliação automática de dificuldade e relevância
+- **Gerenciamento de Interesses**: Sistema dinâmico de interesses do usuário
+- **Recomendações Personalizadas**: Sugestões baseadas no nível de proficiência e contexto
+- **Feeds RSS Integrados**: Acesso a fontes confiáveis de conteúdo em inglês
+- **Extração de Texto**: Processamento automático de URLs para extração de conteúdo
+
+### 2. 🎯 Ambiente de Imersão Interativo
+- **Sistema de Flashcards**: Criação e revisão de vocabulário personalizado
+- **Conversação com IA**: Prática de conversação com feedback inteligente
+- **Exercícios de Escrita**: Prática guiada com correção automática
+- **Geração de Imagens**: Criação de imágenes contextuais para vocabulário
+- **Síntese de Voz**: Pronúncia e áudio com Google Text-to-Speech
+- **Contextos Personalizados**: Adaptação para diferentes contextos (profissional, técnico, social)
+
+### 3. 📊 Planejador de Estudos e Painel de Análise
+- **Planos de Estudo Personalizados**: Cronogramas adaptativos baseados em IA
+- **Análise de Progresso**: Métricas detalhadas de desempenho
+- **Sistema de Marcos**: Objetivos e checkpoints de progresso
+- **Recomendações Adaptativas**: Ajustes automáticos baseados no desempenho
+- **Dashboard de Analytics**: Visualizações de progresso e estatísticas
+- **Tracking de Atividades**: Monitoramento detalhado de todas as atividades
+
+## 🏗️ Arquitetura Técnica
+
+### Backend (Python/Flask)
+- **app.py**: Aplicação principal Flask com todas as rotas
+- **database.py**: Gerenciamento de banco de dados SQLite
+- **content_curator.py**: Motor de curadoria de conteúdo
+- **study_planner.py**: Sistema de planejamento de estudos com IA
+
+### Frontend (HTML/CSS/JavaScript)
+- **index.html**: Interface responsiva e interativa
+- **Design Moderno**: Interface limpa com Tailwind CSS
+- **SPA Experience**: Navegação fluida sem recarregamento
+
+### Banco de Dados
+```sql
+-- Tabelas principais
+users                    -- Usuários e autenticação
+user_settings            -- Configurações personalizadas
+flashcards              -- Sistema de flashcards
+study_sessions          -- Sessões de estudo
+user_articles           -- Artigos salvos pelo usuário
+user_interests          -- Interesses do usuário
+content_recommendations -- Recomendações de conteúdo
+study_plans             -- Planos de estudo
+study_plan_activities   -- Atividades dos planos
+user_analytics          -- Métricas e analytics
+```
+
+### Integrações de IA
+- **Groq**: Processamento de linguagem natural rápido
+- **Google Gemini**: Análise avançada de conteúdo
+- **Google Text-to-Speech**: Síntese de voz
+- **BeautifulSoup**: Web scraping inteligente
+- **FeedParser**: Processamento de feeds RSS
+
+## 🛠️ Instalação e Configuração
+
+### Pré-requisitos
+- Python 3.8+
+- Chaves de API:
+  - `GROQ_API_KEY`: Para processamento de linguagem
+  - `GEMINI_API_KEY`: Para análise de conteúdo
+  - `SECRET_KEY`: Para segurança da sessão
+
+### Instalação
+```bash
+# Clone o repositório
+git clone <repository-url>
+cd englishhelper
+
+# Instale as dependências
+pip install -r requirements.txt
+
+# Configure as variáveis de ambiente
+export GROQ_API_KEY="sua-chave-groq"
+export GEMINI_API_KEY="sua-chave-gemini"
+export SECRET_KEY="sua-chave-secreta"
+
+# Execute a aplicação
+python run.py
+```
+
+### Configuração de Desenvolvimento
+```bash
+# Para desenvolvimento
+export FLASK_DEBUG=true
+python app.py
+```
+
+## 📚 Como Usar
+
+### 1. Criação de Conta
+1. Acesse a aplicação no navegador
+2. Registre-se com email e senha
+3. Confirme seu email (opcional)
+4. Configure seu perfil (nível, interesses, contexto)
+
+### 2. Curadoria de Conteúdo
+1. **Buscar Conteúdo**: Use a barra de busca para encontrar artigos
+2. **Salvar Artigos**: Clique em "Salvar" para adicionar à sua biblioteca
+3. **Gerenciar Interesses**: Configure seus tópicos de interesse
+4. **Recomendações**: Receba sugestões personalizadas baseadas em IA
+
+### 3. Estudo Interativo
+1. **Flashcards**: Crie e revise vocabulário
+2. **Conversação**: Pratique com o bot de IA
+3. **Escrita**: Complete exercícios guiados
+4. **Imagens**: Gere imagens para contextualizar vocabulário
+
+### 4. Planejamento de Estudos
+1. **Gerar Plano**: Configure seu nível atual e objetivo
+2. **Seguir Atividades**: Complete as atividades sugeridas
+3. **Marcar Progresso**: Registre suas atividades concluídas
+4. **Acompanhar Analytics**: Monitore seu progresso
+
+## 🎯 Níveis Suportados
+
+O sistema suporta todos os níveis do Quadro Europeu Comum:
+- **A1**: Básico - vocabulário essencial e frases simples
+- **A2**: Elementar - situações cotidianas e tempos verbais básicos
+- **B1**: Intermediário - conversas mais complexas e opiniões
+- **B2**: Intermediário Superior - textos complexos e apresentações
+- **C1**: Avançado - textos acadêmicos e expressões sofisticadas
+- **C2**: Proficiência - fluência nativa e literatura
+
+## 🔧 Contextos de Aprendizado
+
+### Profissional/Negócios
+- Vocabulário corporativo
+- Apresentações e relatórios
+- Comunicação formal
+- Networking e reuniões
+
+### Técnico/TI
+- Terminologia técnica
+- Documentação especializada
+- Comunicação em equipes de desenvolvimento
+- Artigos de tecnologia
+
+### Geral/Social
+- Conversação cotidiana
+- Mídias sociais
+- Entretenimento
+- Viagens e cultura
+
+## 📈 Analytics e Métricas
+
+### Métricas Individuais
+- Tempo total de estudo
+- Palavras aprendidas
+- Artigos lidos
+- Atividades completadas
+- Progresso por nível
+
+### Visualizações
+- Gráficos de progresso temporal
+- Distribuição de atividades
+- Comparação de performance
+- Tendências de aprendizado
+
+## 🚀 Funcionalidades Avançadas
+
+### Sistema de Recomendações
+- Análise de padrões de aprendizado
+- Sugestões adaptativas de conteúdo
+- Personalização baseada em performance
+- Machine Learning para otimização
+
+### Planejamento Inteligente
+- Cronogramas adaptativos
+- Balanceamento de habilidades
+- Ajustes baseados em progresso
+- Marcos e objetivos personalizados
+
+### Curadoria Automática
+- Busca em tempo real
+- Filtros de qualidade
+- Análise de relevância
+- Diversificação de fontes
+
+## 🔐 Segurança e Privacidade
+
+- Autenticação segura com hash de senhas
+- Sessões criptografadas
+- Dados locais em SQLite
+- Sem compartilhamento de dados pessoais
+- Conformidade com boas práticas de segurança
+
+## 🚀 Roadmap Futuro
+
+### Próximas Funcionalidades
+- [ ] Integração com mais APIs de IA
+- [ ] Sistema de gamificação
+- [ ] Comunidade de learners
+- [ ] Certificações integradas
+- [ ] App móvel
+- [ ] Integração com calendários
+- [ ] Suporte a múltiplos idiomas
+
+### Melhorias Técnicas
+- [ ] Cache inteligente
+- [ ] Otimização de performance
+- [ ] Testes automatizados
+- [ ] Deploy em cloud
+- [ ] Monitoramento avançado
+
+## 🤝 Contribuição
+
+Este é um projeto de demonstração das capacidades avançadas de IA para educação. Sugestões e melhorias são bem-vindas!
+
+## 📄 Licença
+
+Projeto desenvolvido para fins educacionais e demonstração de tecnologias avançadas de IA aplicadas ao aprendizado de idiomas.
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**English Helper** - Transformando o aprendizado de inglês com inteligência artificial! 🎓✨

admin.html

@@ -0,0 +1,1083 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>English Helper - Admin Panel</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        .admin-card {
+            @apply bg-white rounded-lg shadow-md p-6 border border-gray-200;
+        }
+        .stat-card {
+            @apply bg-gradient-to-r from-blue-500 to-purple-600 text-white rounded-lg p-4 shadow-md;
+        }
+        .danger-zone {
+            @apply bg-red-50 border border-red-200 rounded-lg p-4;
+        }
+        .success-zone {
+            @apply bg-green-50 border border-green-200 rounded-lg p-4;
+        }
+        .spinner {
+            border: 3px solid #f3f3f3;
+            border-top: 3px solid #3498db;
+            border-radius: 50%;
+            width: 20px;
+            height: 20px;
+            animation: spin 1s linear infinite;
+            display: inline-block;
+            margin-right: 10px;
+        }
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+        .table-container {
+            max-height: 600px;
+            overflow-y: auto;
+        }
+    </style>
+</head>
+<body class="bg-gray-100 min-h-screen">
+    <!-- Admin Login Modal -->
+    <div id="loginModal" class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
+        <div class="bg-white rounded-lg p-8 max-w-md w-full mx-4">
+            <h2 class="text-2xl font-bold mb-6 text-center">🔐 Admin Login</h2>
+            <form id="adminLoginForm">
+                <div class="mb-4">
+                    <label class="block text-gray-700 text-sm font-bold mb-2">Username</label>
+                    <input type="text" id="adminUsername" class="w-full px-3 py-2 border rounded-lg focus:outline-none focus:border-blue-500" required>
+                </div>
+                <div class="mb-6">
+                    <label class="block text-gray-700 text-sm font-bold mb-2">Password</label>
+                    <input type="password" id="adminPassword" class="w-full px-3 py-2 border rounded-lg focus:outline-none focus:border-blue-500" required>
+                </div>
+                <button type="submit" class="w-full bg-blue-500 text-white py-2 px-4 rounded-lg hover:bg-blue-600 transition duration-200">
+                    🚀 Login
+                </button>
+            </form>
+            <div id="loginError" class="mt-4 text-red-600 text-sm hidden"></div>
+        </div>
+    </div>
+
+    <!-- Admin Interface -->
+    <div id="adminInterface" class="hidden">
+        <!-- Header -->
+        <header class="bg-white shadow-md">
+            <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+                <div class="flex justify-between items-center py-4">
+                    <div class="flex items-center">
+                        <h1 class="text-2xl font-bold text-gray-900">🎓 English Helper Admin</h1>
+                    </div>
+                    <div class="flex items-center space-x-4">
+                        <span id="adminUserInfo" class="text-gray-600"></span>
+                        <button onclick="adminLogout()" class="bg-red-500 text-white px-4 py-2 rounded-lg hover:bg-red-600 transition duration-200">
+                            🚪 Logout
+                        </button>
+                    </div>
+                </div>
+            </div>
+        </header>
+
+        <!-- Navigation Tabs -->
+        <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 mt-6">
+            <div class="border-b border-gray-200">
+                <nav class="-mb-px flex space-x-8">
+                    <button onclick="showTab('dashboard')" class="admin-tab active" data-tab="dashboard">
+                        📊 Dashboard
+                    </button>
+                    <button onclick="showTab('users')" class="admin-tab" data-tab="users">
+                        👥 Users
+                    </button>
+                    <button onclick="showTab('database')" class="admin-tab" data-tab="database">
+                        🗄️ Database
+                    </button>
+                    <button onclick="showTab('tokens')" class="admin-tab" data-tab="tokens">
+                        🎯 Token Usage
+                    </button>
+                    <button onclick="showTab('system')" class="admin-tab" data-tab="system">
+                        🖥️ System Health
+                    </button>
+                </nav>
+            </div>
+        </div>
+
+        <!-- Tab Content -->
+        <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-6">
+            <!-- Dashboard Tab -->
+            <div id="dashboardTab" class="tab-content">
+                <h2 class="text-2xl font-bold mb-6">📊 System Dashboard</h2>
+                
+                <!-- System Stats Cards -->
+                <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-6 mb-8">
+                    <div class="stat-card">
+                        <h3 class="text-lg font-semibold mb-2">👥 Total Users</h3>
+                        <p id="totalUsers" class="text-3xl font-bold">-</p>
+                        <p class="text-sm opacity-80">
+                            <span id="newUsersWeek">-</span> this week
+                        </p>
+                    </div>
+                    <div class="stat-card">
+                        <h3 class="text-lg font-semibold mb-2">📚 Study Sessions</h3>
+                        <p id="totalSessions" class="text-3xl font-bold">-</p>
+                        <p class="text-sm opacity-80">All time</p>
+                    </div>
+                    <div class="stat-card">
+                        <h3 class="text-lg font-semibold mb-2">🎯 API Tokens</h3>
+                        <p id="totalTokens" class="text-3xl font-bold">-</p>
+                        <p class="text-sm opacity-80">
+                            $<span id="estimatedCost">-</span> estimated cost
+                        </p>
+                    </div>
+                    <div class="stat-card">
+                        <h3 class="text-lg font-semibold mb-2">📝 Content Items</h3>
+                        <p id="totalContent" class="text-3xl font-bold">-</p>
+                        <p class="text-sm opacity-80">Articles & flashcards</p>
+                    </div>
+                </div>
+
+                <!-- Charts Section -->
+                <div class="grid grid-cols-1 lg:grid-cols-2 gap-6 mb-8">
+                    <div class="admin-card">
+                        <h3 class="text-lg font-semibold mb-4">📈 User Growth</h3>
+                        <canvas id="userGrowthChart" width="400" height="200"></canvas>
+                    </div>
+                    <div class="admin-card">
+                        <h3 class="text-lg font-semibold mb-4">💰 Token Usage Costs</h3>
+                        <canvas id="tokenCostChart" width="400" height="200"></canvas>
+                    </div>
+                </div>
+
+                <!-- Recent Activity -->
+                <div class="admin-card">
+                    <h3 class="text-lg font-semibold mb-4">🔄 Recent Activity</h3>
+                    <div id="recentActivity" class="space-y-2">
+                        <div class="text-center text-gray-500 py-4">Loading recent activity...</div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Users Tab -->
+            <div id="usersTab" class="tab-content hidden">
+                <div class="flex justify-between items-center mb-6">
+                    <h2 class="text-2xl font-bold">👥 User Management</h2>
+                    <div class="flex items-center space-x-4">
+                        <input type="text" id="userSearch" placeholder="Search users..." class="px-4 py-2 border rounded-lg">
+                        <button onclick="refreshUsers()" class="bg-blue-500 text-white px-4 py-2 rounded-lg hover:bg-blue-600">
+                            🔄 Refresh
+                        </button>
+                        <button onclick="exportUsers()" class="bg-green-500 text-white px-4 py-2 rounded-lg hover:bg-green-600">
+                            📥 Export CSV
+                        </button>
+                    </div>
+                </div>
+
+                <!-- Users Table -->
+                <div class="admin-card">
+                    <div class="table-container">
+                        <table class="w-full table-auto">
+                            <thead class="bg-gray-50 sticky top-0">
+                                <tr>
+                                    <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">User</th>
+                                    <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Created</th>
+                                    <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Activity</th>
+                                    <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Status</th>
+                                    <th class="px-4 py-3 text-left text-xs font-medium text-gray-500 uppercase">Actions</th>
+                                </tr>
+                            </thead>
+                            <tbody id="usersTableBody">
+                                <tr>
+                                    <td colspan="5" class="text-center py-8">
+                                        <div class="spinner"></div> Loading users...
+                                    </td>
+                                </tr>
+                            </tbody>
+                        </table>
+                    </div>
+                    
+                    <!-- Pagination -->
+                    <div id="usersPagination" class="flex justify-between items-center mt-4 pt-4 border-t">
+                        <div id="usersInfo" class="text-sm text-gray-600"></div>
+                        <div class="flex space-x-2">
+                            <button onclick="previousPage()" id="prevPageBtn" class="px-3 py-1 bg-gray-300 rounded hover:bg-gray-400 disabled:opacity-50" disabled>Previous</button>
+                            <span id="pageInfo" class="px-3 py-1">-</span>
+                            <button onclick="nextPage()" id="nextPageBtn" class="px-3 py-1 bg-gray-300 rounded hover:bg-gray-400 disabled:opacity-50" disabled>Next</button>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Database Tab -->
+            <div id="databaseTab" class="tab-content hidden">
+                <h2 class="text-2xl font-bold mb-6">🗄️ Database Overview</h2>
+                
+                <div class="admin-card">
+                    <h3 class="text-lg font-semibold mb-4">📋 Database Schema</h3>
+                    <div id="databaseSchema" class="space-y-4">
+                        <div class="text-center text-gray-500 py-4">Loading schema...</div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Token Usage Tab -->
+            <div id="tokensTab" class="tab-content hidden">
+                <div class="flex justify-between items-center mb-6">
+                    <h2 class="text-2xl font-bold">🎯 Token Usage Analytics</h2>
+                    <button onclick="exportTokens()" class="bg-green-500 text-white px-4 py-2 rounded-lg hover:bg-green-600">
+                        📥 Export Token Data
+                    </button>
+                </div>
+                
+                <div class="grid grid-cols-1 lg:grid-cols-2 gap-6">
+                    <div class="admin-card">
+                        <h3 class="text-lg font-semibold mb-4">📊 Usage by Provider</h3>
+                        <canvas id="providerUsageChart" width="400" height="300"></canvas>
+                    </div>
+                    <div class="admin-card">
+                        <h3 class="text-lg font-semibold mb-4">💰 Cost Breakdown</h3>
+                        <canvas id="costBreakdownChart" width="400" height="300"></canvas>
+                    </div>
+                </div>
+            </div>
+
+            <!-- System Health Tab -->
+            <div id="systemTab" class="tab-content hidden">
+                <h2 class="text-2xl font-bold mb-6">🖥️ System Health Monitor</h2>
+                
+                <!-- System Alerts -->
+                <div class="admin-card mb-6">
+                    <h3 class="text-lg font-semibold mb-4">⚠️ System Alerts</h3>
+                    <div id="systemAlerts">
+                        <div class="text-center text-gray-500 py-4">Loading alerts...</div>
+                    </div>
+                </div>
+
+                <!-- System Metrics -->
+                <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6 mb-6">
+                    <div class="admin-card">
+                        <h4 class="font-semibold mb-3">💾 Memory Usage</h4>
+                        <div id="memoryMetrics">
+                            <div class="text-sm text-gray-500">Loading...</div>
+                        </div>
+                    </div>
+                    
+                    <div class="admin-card">
+                        <h4 class="font-semibold mb-3">💿 Disk Usage</h4>
+                        <div id="diskMetrics">
+                            <div class="text-sm text-gray-500">Loading...</div>
+                        </div>
+                    </div>
+                    
+                    <div class="admin-card">
+                        <h4 class="font-semibold mb-3">🗄️ Database</h4>
+                        <div id="databaseMetrics">
+                            <div class="text-sm text-gray-500">Loading...</div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Error Logs -->
+                <div class="admin-card">
+                    <h3 class="text-lg font-semibold mb-4">🚨 Recent Errors</h3>
+                    <div id="errorLogs">
+                        <div class="text-center text-gray-500 py-4">Loading error logs...</div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- User Detail Modal -->
+    <div id="userDetailModal" class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 hidden">
+        <div class="bg-white rounded-lg p-6 max-w-4xl w-full mx-4 max-h-screen overflow-y-auto">
+            <div class="flex justify-between items-center mb-4">
+                <h3 class="text-xl font-bold">👤 User Details</h3>
+                <button onclick="closeUserModal()" class="text-gray-500 hover:text-gray-700">✕</button>
+            </div>
+            <div id="userDetailContent">
+                <div class="text-center py-8">Loading user details...</div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Toast Notifications -->
+    <div id="toastContainer" class="fixed top-4 right-4 z-50"></div>
+
+    <script>
+        let currentUser = null;
+        let currentPage = 1;
+        let usersData = null;
+        
+        // Check admin authentication on load
+        document.addEventListener('DOMContentLoaded', () => {
+            checkAdminAuth();
+        });
+
+        async function checkAdminAuth() {
+            try {
+                const response = await fetch('/admin/check');
+                const data = await response.json();
+                
+                if (data.authenticated) {
+                    showAdminInterface(data.username);
+                } else {
+                    showLoginModal();
+                }
+            } catch (error) {
+                console.error('Auth check error:', error);
+                showLoginModal();
+            }
+        }
+
+        function showLoginModal() {
+            document.getElementById('loginModal').classList.remove('hidden');
+            document.getElementById('adminInterface').classList.add('hidden');
+        }
+
+        function showAdminInterface(username) {
+            document.getElementById('loginModal').classList.add('hidden');
+            document.getElementById('adminInterface').classList.remove('hidden');
+            document.getElementById('adminUserInfo').textContent = `Welcome, ${username}`;
+            
+            // Load dashboard data
+            loadDashboard();
+        }
+
+        // Admin login
+        document.getElementById('adminLoginForm').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            
+            const username = document.getElementById('adminUsername').value;
+            const password = document.getElementById('adminPassword').value;
+            const errorDiv = document.getElementById('loginError');
+            
+            try {
+                const response = await fetch('/admin/login', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ username, password })
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    showAdminInterface(username);
+                    errorDiv.classList.add('hidden');
+                } else {
+                    errorDiv.textContent = data.error || 'Login failed';
+                    errorDiv.classList.remove('hidden');
+                }
+            } catch (error) {
+                errorDiv.textContent = 'Network error. Please try again.';
+                errorDiv.classList.remove('hidden');
+            }
+        });
+
+        async function adminLogout() {
+            try {
+                await fetch('/admin/logout', { method: 'POST' });
+                showLoginModal();
+                showToast('Logged out successfully', 'success');
+            } catch (error) {
+                console.error('Logout error:', error);
+            }
+        }
+
+        // Tab management
+        function showTab(tabName) {
+            // Hide all tabs
+            document.querySelectorAll('.tab-content').forEach(tab => {
+                tab.classList.add('hidden');
+            });
+            
+            // Remove active class from all tab buttons
+            document.querySelectorAll('.admin-tab').forEach(btn => {
+                btn.classList.remove('active', 'border-blue-500', 'text-blue-600');
+                btn.classList.add('border-transparent', 'text-gray-500');
+            });
+            
+            // Show selected tab
+            document.getElementById(tabName + 'Tab').classList.remove('hidden');
+            
+            // Add active class to selected tab button
+            const activeBtn = document.querySelector(`[data-tab="${tabName}"]`);
+            activeBtn.classList.add('active', 'border-blue-500', 'text-blue-600');
+            activeBtn.classList.remove('border-transparent', 'text-gray-500');
+            
+            // Load tab-specific data
+            if (tabName === 'dashboard') {
+                loadDashboard();
+            } else if (tabName === 'users') {
+                loadUsers();
+            } else if (tabName === 'database') {
+                loadDatabaseSchema();
+            } else if (tabName === 'tokens') {
+                loadTokenUsage();
+            } else if (tabName === 'system') {
+                loadSystemHealth();
+            }
+        }
+
+        async function loadDashboard() {
+            try {
+                const response = await fetch('/admin/dashboard');
+                const data = await response.json();
+                
+                if (data.success) {
+                    const stats = data.stats;
+                    
+                    // Update stat cards
+                    document.getElementById('totalUsers').textContent = stats.users?.total || 0;
+                    document.getElementById('newUsersWeek').textContent = stats.users?.new_week || 0;
+                    document.getElementById('totalSessions').textContent = stats.activity?.total_sessions || 0;
+                    document.getElementById('totalTokens').textContent = (stats.api_usage?.total_tokens || 0).toLocaleString();
+                    document.getElementById('estimatedCost').textContent = stats.api_usage?.estimated_cost || '0.00';
+                    document.getElementById('totalContent').textContent = 
+                        (stats.activity?.total_flashcards || 0) + (stats.activity?.total_articles || 0);
+                    
+                    // Update recent activity
+                    updateRecentActivity(stats.recent_activity || []);
+                    
+                    // Create charts
+                    createCharts(stats);
+                }
+            } catch (error) {
+                console.error('Dashboard loading error:', error);
+                showToast('Failed to load dashboard', 'error');
+            }
+        }
+
+        function updateRecentActivity(activities) {
+            const container = document.getElementById('recentActivity');
+            
+            if (activities.length === 0) {
+                container.innerHTML = '<div class="text-center text-gray-500 py-4">No recent activity</div>';
+                return;
+            }
+            
+            container.innerHTML = activities.map(activity => `
+                <div class="flex items-center justify-between py-2 border-b border-gray-100">
+                    <div>
+                        <span class="font-medium">${activity.user}</span>
+                        <span class="text-gray-600">performed ${activity.activity}</span>
+                    </div>
+                    <span class="text-sm text-gray-500">${formatDate(activity.timestamp)}</span>
+                </div>
+            `).join('');
+        }
+
+        async function loadUsers() {
+            try {
+                const response = await fetch(`/admin/users?page=${currentPage}&per_page=20`);
+                const data = await response.json();
+                
+                if (data.success) {
+                    usersData = data.data;
+                    updateUsersTable(usersData.users);
+                    updateUsersPagination(usersData);
+                }
+            } catch (error) {
+                console.error('Users loading error:', error);
+                showToast('Failed to load users', 'error');
+            }
+        }
+
+        function updateUsersTable(users) {
+            const tbody = document.getElementById('usersTableBody');
+            
+            if (users.length === 0) {
+                tbody.innerHTML = '<tr><td colspan="5" class="text-center py-8">No users found</td></tr>';
+                return;
+            }
+            
+            tbody.innerHTML = users.map(user => `
+                <tr class="border-b hover:bg-gray-50">
+                    <td class="px-4 py-3">
+                        <div>
+                            <div class="font-medium">${user.email}</div>
+                            <div class="text-sm text-gray-500">ID: ${user.id}</div>
+                        </div>
+                    </td>
+                    <td class="px-4 py-3 text-sm text-gray-600">
+                        ${formatDate(user.created_at)}
+                    </td>
+                    <td class="px-4 py-3">
+                        <div class="text-sm">
+                            <div>${user.session_count} sessions</div>
+                            <div class="text-gray-500">${user.flashcard_count} cards, ${user.article_count} articles</div>
+                        </div>
+                    </td>
+                    <td class="px-4 py-3">
+                        <span class="px-2 py-1 text-xs rounded-full ${user.email_confirmed ? 'bg-green-100 text-green-800' : 'bg-yellow-100 text-yellow-800'}">
+                            ${user.email_confirmed ? 'Confirmed' : 'Unconfirmed'}
+                        </span>
+                    </td>
+                    <td class="px-4 py-3">
+                        <div class="flex space-x-2">
+                            <button onclick="viewUser(${user.id})" class="text-blue-600 hover:text-blue-800 text-sm">👁️ View</button>
+                            <button onclick="deleteUser(${user.id}, '${user.email}')" class="text-red-600 hover:text-red-800 text-sm">🗑️ Delete</button>
+                        </div>
+                    </td>
+                </tr>
+            `).join('');
+        }
+
+        function updateUsersPagination(data) {
+            document.getElementById('usersInfo').textContent = 
+                `Showing ${((data.page - 1) * data.per_page) + 1}-${Math.min(data.page * data.per_page, data.total)} of ${data.total} users`;
+            
+            document.getElementById('pageInfo').textContent = `Page ${data.page} of ${data.total_pages}`;
+            
+            document.getElementById('prevPageBtn').disabled = data.page <= 1;
+            document.getElementById('nextPageBtn').disabled = data.page >= data.total_pages;
+        }
+
+        async function viewUser(userId) {
+            try {
+                const response = await fetch(`/admin/users/${userId}`);
+                const data = await response.json();
+                
+                if (data.success) {
+                    showUserModal(data.user);
+                }
+            } catch (error) {
+                console.error('User details error:', error);
+                showToast('Failed to load user details', 'error');
+            }
+        }
+
+        function showUserModal(user) {
+            const modal = document.getElementById('userDetailModal');
+            const content = document.getElementById('userDetailContent');
+            
+            content.innerHTML = `
+                <div class="grid grid-cols-1 lg:grid-cols-2 gap-6">
+                    <div>
+                        <h4 class="font-semibold mb-3">📋 Basic Information</h4>
+                        <div class="space-y-2 text-sm">
+                            <div><strong>Email:</strong> ${user.user.email}</div>
+                            <div><strong>ID:</strong> ${user.user.id}</div>
+                            <div><strong>Created:</strong> ${formatDate(user.user.created_at)}</div>
+                            <div><strong>Last Login:</strong> ${user.user.last_login ? formatDate(user.user.last_login) : 'Never'}</div>
+                            <div><strong>Email Confirmed:</strong> ${user.user.email_confirmed ? '✅ Yes' : '❌ No'}</div>
+                        </div>
+                    </div>
+                    
+                    <div>
+                        <h4 class="font-semibold mb-3">⚙️ Settings</h4>
+                        <div class="space-y-2 text-sm">
+                            ${Object.entries(user.settings).map(([key, value]) => 
+                                `<div><strong>${key}:</strong> ${value}</div>`
+                            ).join('')}
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="mt-6">
+                    <h4 class="font-semibold mb-3">📊 Recent Activity</h4>
+                    <div class="max-h-48 overflow-y-auto">
+                        ${user.recent_sessions.map(session => `
+                            <div class="flex justify-between py-2 border-b text-sm">
+                                <span>${session.activity}</span>
+                                <span class="text-gray-500">${formatDate(session.timestamp)}</span>
+                            </div>
+                        `).join('')}
+                    </div>
+                </div>
+                
+                <div class="mt-6">
+                    <h4 class="font-semibold mb-3">🎯 Token Usage</h4>
+                    <div class="grid grid-cols-1 sm:grid-cols-2 gap-4">
+                        ${user.token_usage.map(usage => `
+                            <div class="bg-gray-50 p-3 rounded">
+                                <div class="font-medium">${usage.provider}</div>
+                                <div class="text-sm text-gray-600">
+                                    Input: ${usage.input_tokens.toLocaleString()}<br>
+                                    Output: ${usage.output_tokens.toLocaleString()}<br>
+                                    Calls: ${usage.calls}
+                                </div>
+                            </div>
+                        `).join('')}
+                    </div>
+                </div>
+            `;
+            
+            modal.classList.remove('hidden');
+        }
+
+        function closeUserModal() {
+            document.getElementById('userDetailModal').classList.add('hidden');
+        }
+
+        async function deleteUser(userId, email) {
+            if (!confirm(`Are you sure you want to delete user "${email}" and all their data? This action cannot be undone.`)) {
+                return;
+            }
+            
+            try {
+                const response = await fetch(`/admin/users/${userId}`, {
+                    method: 'DELETE'
+                });
+                
+                const data = await response.json();
+                
+                if (data.success) {
+                    showToast('User deleted successfully', 'success');
+                    loadUsers(); // Refresh the table
+                } else {
+                    showToast('Failed to delete user', 'error');
+                }
+            } catch (error) {
+                console.error('Delete user error:', error);
+                showToast('Failed to delete user', 'error');
+            }
+        }
+
+        async function loadDatabaseSchema() {
+            try {
+                const response = await fetch('/admin/database/schema');
+                const data = await response.json();
+                
+                if (data.success) {
+                    updateDatabaseSchema(data.schema);
+                }
+            } catch (error) {
+                console.error('Schema loading error:', error);
+                showToast('Failed to load database schema', 'error');
+            }
+        }
+
+        function updateDatabaseSchema(schema) {
+            const container = document.getElementById('databaseSchema');
+            
+            container.innerHTML = Object.entries(schema).map(([tableName, tableInfo]) => `
+                <div class="border rounded-lg p-4">
+                    <div class="flex justify-between items-center mb-3">
+                        <h5 class="font-semibold text-lg">${tableName}</h5>
+                        <span class="bg-blue-100 text-blue-800 px-2 py-1 rounded text-sm">
+                            ${tableInfo.row_count} rows
+                        </span>
+                    </div>
+                    <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-2 text-sm">
+                        ${tableInfo.columns.map(col => `
+                            <div class="flex items-center space-x-2">
+                                <span class="font-medium">${col.name}</span>
+                                <span class="text-gray-500">${col.type}</span>
+                                ${col.primary_key ? '<span class="bg-yellow-100 text-yellow-800 px-1 rounded text-xs">PK</span>' : ''}
+                                ${col.not_null ? '<span class="bg-red-100 text-red-800 px-1 rounded text-xs">NOT NULL</span>' : ''}
+                            </div>
+                        `).join('')}
+                    </div>
+                </div>
+            `).join('');
+        }
+
+        async function loadTokenUsage() {
+            try {
+                // For now, create sample charts with existing data
+                await createTokenUsageCharts();
+            } catch (error) {
+                console.error('Token usage loading error:', error);
+                showToast('Failed to load token usage data', 'error');
+            }
+        }
+
+        async function createTokenUsageCharts() {
+            // Provider Usage Chart
+            const providerCtx = document.getElementById('providerUsageChart').getContext('2d');
+            
+            new Chart(providerCtx, {
+                type: 'bar',
+                data: {
+                    labels: ['Groq', 'Gemini'],
+                    datasets: [{
+                        label: 'Input Tokens',
+                        data: [150000, 85000],
+                        backgroundColor: 'rgba(59, 130, 246, 0.8)',
+                        borderColor: 'rgba(59, 130, 246, 1)',
+                        borderWidth: 1
+                    }, {
+                        label: 'Output Tokens',
+                        data: [45000, 28000],
+                        backgroundColor: 'rgba(147, 51, 234, 0.8)',
+                        borderColor: 'rgba(147, 51, 234, 1)',
+                        borderWidth: 1
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    plugins: {
+                        title: {
+                            display: true,
+                            text: 'Token Usage by Provider'
+                        }
+                    },
+                    scales: {
+                        y: {
+                            beginAtZero: true,
+                            title: {
+                                display: true,
+                                text: 'Tokens'
+                            }
+                        }
+                    }
+                }
+            });
+
+            // Cost Breakdown Chart
+            const costCtx = document.getElementById('costBreakdownChart').getContext('2d');
+            
+            new Chart(costCtx, {
+                type: 'pie',
+                data: {
+                    labels: ['Conversation', 'Content Analysis', 'Recommendations', 'Study Planning'],
+                    datasets: [{
+                        data: [40, 25, 20, 15],
+                        backgroundColor: [
+                            'rgba(34, 197, 94, 0.8)',
+                            'rgba(59, 130, 246, 0.8)',
+                            'rgba(147, 51, 234, 0.8)',
+                            'rgba(251, 146, 60, 0.8)'
+                        ],
+                        borderColor: [
+                            'rgba(34, 197, 94, 1)',
+                            'rgba(59, 130, 246, 1)',
+                            'rgba(147, 51, 234, 1)',
+                            'rgba(251, 146, 60, 1)'
+                        ],
+                        borderWidth: 2
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    plugins: {
+                        title: {
+                            display: true,
+                            text: 'Cost Distribution by Operation Type'
+                        },
+                        legend: {
+                            position: 'bottom'
+                        }
+                    }
+                }
+            });
+        }
+
+        function refreshUsers() {
+            currentPage = 1;
+            loadUsers();
+        }
+
+        function previousPage() {
+            if (currentPage > 1) {
+                currentPage--;
+                loadUsers();
+            }
+        }
+
+        function nextPage() {
+            if (usersData && currentPage < usersData.total_pages) {
+                currentPage++;
+                loadUsers();
+            }
+        }
+
+        function createCharts(stats) {
+            createUserGrowthChart(stats);
+            createTokenCostChart(stats);
+        }
+
+        function createUserGrowthChart(stats) {
+            const ctx = document.getElementById('userGrowthChart').getContext('2d');
+            
+            // Generate sample data for last 30 days
+            const dates = [];
+            const userData = [];
+            const today = new Date();
+            
+            for (let i = 29; i >= 0; i--) {
+                const date = new Date(today);
+                date.setDate(date.getDate() - i);
+                dates.push(date.toLocaleDateString());
+                
+                // Simulate growth data (would come from real analytics)
+                userData.push(Math.max(0, stats.users?.total - Math.floor(Math.random() * i * 2)));
+            }
+            
+            new Chart(ctx, {
+                type: 'line',
+                data: {
+                    labels: dates,
+                    datasets: [{
+                        label: 'Total Users',
+                        data: userData,
+                        borderColor: 'rgb(59, 130, 246)',
+                        backgroundColor: 'rgba(59, 130, 246, 0.1)',
+                        fill: true,
+                        tension: 0.4
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    plugins: {
+                        title: {
+                            display: true,
+                            text: 'User Growth Over Time'
+                        }
+                    },
+                    interaction: {
+                        intersect: false,
+                    },
+                    scales: {
+                        x: {
+                            display: true,
+                            title: {
+                                display: true,
+                                text: 'Date'
+                            }
+                        },
+                        y: {
+                            display: true,
+                            title: {
+                                display: true,
+                                text: 'Users'
+                            }
+                        }
+                    }
+                }
+            });
+        }
+
+        function createTokenCostChart(stats) {
+            const ctx = document.getElementById('tokenCostChart').getContext('2d');
+            
+            // Sample cost data
+            const providers = ['Groq', 'Gemini'];
+            const costs = [
+                (stats.api_usage?.estimated_cost || 0) * 0.6, // Groq portion
+                (stats.api_usage?.estimated_cost || 0) * 0.4  // Gemini portion
+            ];
+            
+            new Chart(ctx, {
+                type: 'doughnut',
+                data: {
+                    labels: providers,
+                    datasets: [{
+                        label: 'Cost ($)',
+                        data: costs,
+                        backgroundColor: [
+                            'rgba(59, 130, 246, 0.8)',
+                            'rgba(147, 51, 234, 0.8)'
+                        ],
+                        borderColor: [
+                            'rgba(59, 130, 246, 1)',
+                            'rgba(147, 51, 234, 1)'
+                        ],
+                        borderWidth: 2
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    plugins: {
+                        title: {
+                            display: true,
+                            text: 'API Costs by Provider'
+                        },
+                        legend: {
+                            position: 'bottom',
+                        }
+                    }
+                }
+            });
+        }
+
+        function exportUsers() {
+            window.open('/admin/export/users', '_blank');
+            showToast('Users data export started', 'success');
+        }
+
+        function exportTokens() {
+            window.open('/admin/export/tokens', '_blank');
+            showToast('Token usage data export started', 'success');
+        }
+
+        async function loadSystemHealth() {
+            try {
+                // Load system health metrics
+                const healthResponse = await fetch('/admin/system/health');
+                const healthData = await healthResponse.json();
+                
+                if (healthData.success) {
+                    updateSystemMetrics(healthData.health);
+                }
+                
+                // Load system alerts
+                const alertsResponse = await fetch('/admin/system/alerts');
+                const alertsData = await alertsResponse.json();
+                
+                if (alertsData.success) {
+                    updateSystemAlerts(alertsData.alerts);
+                }
+            } catch (error) {
+                console.error('System health loading error:', error);
+                showToast('Failed to load system health data', 'error');
+            }
+        }
+
+        function updateSystemMetrics(health) {
+            // Memory metrics
+            if (health.memory) {
+                const memoryPercent = health.memory.percent || 0;
+                const memoryUsed = Math.round(health.memory.used / 1024 / 1024 / 1024 * 100) / 100;
+                const memoryTotal = Math.round(health.memory.total / 1024 / 1024 / 1024 * 100) / 100;
+                
+                document.getElementById('memoryMetrics').innerHTML = `
+                    <div class="space-y-2">
+                        <div class="flex justify-between">
+                            <span>Used:</span>
+                            <span>${memoryUsed}GB / ${memoryTotal}GB</span>
+                        </div>
+                        <div class="w-full bg-gray-200 rounded-full h-2">
+                            <div class="bg-blue-600 h-2 rounded-full" style="width: ${memoryPercent}%"></div>
+                        </div>
+                        <div class="text-xs text-gray-500">${memoryPercent.toFixed(1)}% used</div>
+                    </div>
+                `;
+            }
+            
+            // Disk metrics
+            if (health.disk) {
+                const diskPercent = health.disk.percent || 0;
+                const diskUsed = Math.round(health.disk.used / 1024 / 1024 / 1024 * 100) / 100;
+                const diskTotal = Math.round(health.disk.total / 1024 / 1024 / 1024 * 100) / 100;
+                
+                document.getElementById('diskMetrics').innerHTML = `
+                    <div class="space-y-2">
+                        <div class="flex justify-between">
+                            <span>Used:</span>
+                            <span>${diskUsed}GB / ${diskTotal}GB</span>
+                        </div>
+                        <div class="w-full bg-gray-200 rounded-full h-2">
+                            <div class="bg-green-600 h-2 rounded-full" style="width: ${diskPercent}%"></div>
+                        </div>
+                        <div class="text-xs text-gray-500">${diskPercent.toFixed(1)}% used</div>
+                    </div>
+                `;
+            }
+            
+            // Database metrics
+            if (health.database) {
+                document.getElementById('databaseMetrics').innerHTML = `
+                    <div class="space-y-2">
+                        <div class="flex justify-between">
+                            <span>Size:</span>
+                            <span>${health.database.size_mb}MB</span>
+                        </div>
+                        <div class="flex justify-between">
+                            <span>Uptime:</span>
+                            <span>${health.uptime || 'Unknown'}</span>
+                        </div>
+                    </div>
+                `;
+            }
+            
+            // Error logs
+            if (health.recent_errors && health.recent_errors.length > 0) {
+                document.getElementById('errorLogs').innerHTML = `
+                    <div class="space-y-2 max-h-64 overflow-y-auto">
+                        ${health.recent_errors.map(error => `
+                            <div class="p-2 bg-red-50 border border-red-200 rounded text-sm">
+                                <div class="flex justify-between items-start">
+                                    <span class="font-medium text-red-800">${error.level}</span>
+                                    <span class="text-red-600 text-xs">${error.timestamp}</span>
+                                </div>
+                                <div class="text-red-700 mt-1">${error.message}</div>
+                                <div class="text-red-600 text-xs mt-1">Module: ${error.module}</div>
+                            </div>
+                        `).join('')}
+                    </div>
+                `;
+            } else {
+                document.getElementById('errorLogs').innerHTML = '<div class="text-center text-gray-500 py-4">No recent errors</div>';
+            }
+        }
+
+        function updateSystemAlerts(alerts) {
+            const container = document.getElementById('systemAlerts');
+            
+            if (alerts.length === 0) {
+                container.innerHTML = '<div class="text-center text-green-600 py-4">✅ All systems normal</div>';
+                return;
+            }
+            
+            container.innerHTML = alerts.map(alert => {
+                const bgColor = alert.type === 'error' ? 'bg-red-50 border-red-200' : 
+                               alert.type === 'warning' ? 'bg-yellow-50 border-yellow-200' : 
+                               'bg-blue-50 border-blue-200';
+                const textColor = alert.type === 'error' ? 'text-red-800' : 
+                                 alert.type === 'warning' ? 'text-yellow-800' : 
+                                 'text-blue-800';
+                const icon = alert.type === 'error' ? '🚨' : 
+                            alert.type === 'warning' ? '⚠️' : 'ℹ️';
+                
+                return `
+                    <div class="p-3 ${bgColor} border rounded-lg">
+                        <div class="flex items-start gap-3">
+                            <span class="text-lg">${icon}</span>
+                            <div class="flex-1">
+                                <div class="font-medium ${textColor}">${alert.message}</div>
+                                <div class="text-sm ${textColor} opacity-75 mt-1">Action: ${alert.action}</div>
+                            </div>
+                        </div>
+                    </div>
+                `;
+            }).join('');
+        }
+
+        function formatDate(dateString) {
+            if (!dateString) return 'Never';
+            return new Date(dateString).toLocaleDateString() + ' ' + new Date(dateString).toLocaleTimeString();
+        }
+
+        function showToast(message, type = 'info') {
+            const toast = document.createElement('div');
+            toast.className = `fixed top-4 right-4 p-4 rounded-lg shadow-md z-50 ${
+                type === 'success' ? 'bg-green-500' : 
+                type === 'error' ? 'bg-red-500' : 
+                type === 'warning' ? 'bg-yellow-500' : 'bg-blue-500'
+            } text-white`;
+            
+            toast.textContent = message;
+            document.body.appendChild(toast);
+            
+            setTimeout(() => {
+                toast.remove();
+            }, 5000);
+        }
+
+        // Add CSS for tab styling
+        const style = document.createElement('style');
+        style.textContent = `
+            .admin-tab {
+                padding: 0.5rem 1rem;
+                border-bottom: 2px solid transparent;
+                font-medium: 500;
+                text-decoration: none;
+                transition: all 0.2s;
+            }
+            .admin-tab:hover {
+                text-decoration: none;
+                border-bottom-color: #d1d5db;
+            }
+            .admin-tab.active {
+                border-bottom-color: #3b82f6;
+                color: #3b82f6;
+            }
+        `;
+        document.head.appendChild(style);
+    </script>
+</body>
+</html>

admin_module.py

@@ -0,0 +1,524 @@
+# admin_module.py - Administrative interface for English Helper
+import os
+import json
+import hashlib
+from datetime import datetime, timedelta
+from functools import wraps
+from flask import session, request, jsonify, redirect, url_for
+import sqlite3
+from database import get_db_connection
+import logging
+
+logger = logging.getLogger(__name__)
+
+class AdminManager:
+    def __init__(self):
+        self.admin_credentials = self._load_admin_credentials()
+        self.token_costs = {
+            'groq': {'input': 0.00000059, 'output': 0.00000079},  # per token
+            'gemini': {'input': 0.00000125, 'output': 0.00000375}  # per token
+        }
+    
+    def _load_admin_credentials(self):
+        """Load admin credentials from environment variables (Hugging Face secrets)"""
+        try:
+            # Try to load from Hugging Face secrets format
+            admin_user = os.environ.get('ADMIN_USERNAME', 'admin')
+            admin_pass = os.environ.get('ADMIN_PASSWORD', 'admin123')
+            
+            # For security, hash the password
+            admin_pass_hash = hashlib.sha256(admin_pass.encode()).hexdigest()
+            
+            return {
+                'username': admin_user,
+                'password_hash': admin_pass_hash,
+                'original_password': admin_pass  # Store for initial comparison
+            }
+        except Exception as e:
+            logger.error(f"Error loading admin credentials: {e}")
+            # Fallback credentials
+            return {
+                'username': 'admin',
+                'password_hash': hashlib.sha256('admin123'.encode()).hexdigest(),
+                'original_password': 'admin123'
+            }
+    
+    def authenticate_admin(self, username, password):
+        """Authenticate admin user"""
+        try:
+            if username != self.admin_credentials['username']:
+                return False
+            
+            # Check password hash
+            password_hash = hashlib.sha256(password.encode()).hexdigest()
+            return password_hash == self.admin_credentials['password_hash']
+        except Exception as e:
+            logger.error(f"Admin authentication error: {e}")
+            return False
+    
+    def is_admin_logged_in(self):
+        """Check if admin is logged in"""
+        return session.get('admin_authenticated', False)
+    
+    def login_admin(self, username, password):
+        """Admin login"""
+        if self.authenticate_admin(username, password):
+            session['admin_authenticated'] = True
+            session['admin_username'] = username
+            session['admin_login_time'] = datetime.now().isoformat()
+            return True
+        return False
+    
+    def logout_admin(self):
+        """Admin logout"""
+        session.pop('admin_authenticated', None)
+        session.pop('admin_username', None)
+        session.pop('admin_login_time', None)
+    
+    def get_system_stats(self):
+        """Get comprehensive system statistics"""
+        try:
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            
+            # User statistics
+            cursor.execute("SELECT COUNT(*) FROM users")
+            total_users = cursor.fetchone()[0]
+            
+            cursor.execute("SELECT COUNT(*) FROM users WHERE created_at > datetime('now', '-7 days')")
+            new_users_week = cursor.fetchone()[0]
+            
+            cursor.execute("SELECT COUNT(*) FROM users WHERE created_at > datetime('now', '-1 day')")
+            new_users_today = cursor.fetchone()[0]
+            
+            # Activity statistics
+            cursor.execute("SELECT COUNT(*) FROM study_sessions")
+            total_sessions = cursor.fetchone()[0]
+            
+            cursor.execute("SELECT COUNT(*) FROM flashcards")
+            total_flashcards = cursor.fetchone()[0]
+            
+            cursor.execute("SELECT COUNT(*) FROM user_articles")
+            total_articles = cursor.fetchone()[0]
+            
+            cursor.execute("SELECT COUNT(*) FROM study_plans")
+            total_study_plans = cursor.fetchone()[0]
+            
+            # Token usage statistics
+            cursor.execute("SELECT SUM(tokens_used), COUNT(*) FROM token_usage")
+            token_stats = cursor.fetchone()
+            total_tokens = token_stats[0] if token_stats[0] else 0
+            total_api_calls = token_stats[1] if token_stats[1] else 0
+            
+            # Calculate estimated costs
+            estimated_cost = self._calculate_estimated_cost(cursor)
+            
+            # Recent activity
+            cursor.execute("""
+                SELECT u.email, s.created_at, s.activity_type 
+                FROM study_sessions s 
+                JOIN users u ON s.user_id = u.id 
+                ORDER BY s.created_at DESC 
+                LIMIT 10
+            """)
+            recent_activity = cursor.fetchall()
+            
+            conn.close()
+            
+            return {
+                'users': {
+                    'total': total_users,
+                    'new_week': new_users_week,
+                    'new_today': new_users_today
+                },
+                'activity': {
+                    'total_sessions': total_sessions,
+                    'total_flashcards': total_flashcards,
+                    'total_articles': total_articles,
+                    'total_study_plans': total_study_plans
+                },
+                'api_usage': {
+                    'total_tokens': total_tokens,
+                    'total_calls': total_api_calls,
+                    'estimated_cost': estimated_cost
+                },
+                'recent_activity': [
+                    {
+                        'user': activity[0],
+                        'timestamp': activity[1],
+                        'activity': activity[2]
+                    } for activity in recent_activity
+                ]
+            }
+        except Exception as e:
+            logger.error(f"Error getting system stats: {e}")
+            return {}
+    
+    def _calculate_estimated_cost(self, cursor):
+        """Calculate estimated API costs"""
+        try:
+            cursor.execute("""
+                SELECT api_provider, SUM(input_tokens), SUM(output_tokens) 
+                FROM token_usage 
+                GROUP BY api_provider
+            """)
+            usage_by_provider = cursor.fetchall()
+            
+            total_cost = 0
+            for provider, input_tokens, output_tokens in usage_by_provider:
+                if provider in self.token_costs:
+                    costs = self.token_costs[provider]
+                    total_cost += (input_tokens * costs['input']) + (output_tokens * costs['output'])
+            
+            return round(total_cost, 4)
+        except:
+            return 0
+    
+    def get_all_users(self, page=1, per_page=20):
+        """Get paginated list of all users"""
+        try:
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            
+            offset = (page - 1) * per_page
+            
+            cursor.execute("""
+                SELECT u.id, u.email, u.created_at, u.email_confirmed, u.last_login,
+                       COUNT(DISTINCT s.id) as session_count,
+                       COUNT(DISTINCT f.id) as flashcard_count,
+                       COUNT(DISTINCT a.id) as article_count
+                FROM users u
+                LEFT JOIN study_sessions s ON u.id = s.user_id
+                LEFT JOIN flashcards f ON u.id = f.user_id
+                LEFT JOIN user_articles a ON u.id = a.user_id
+                GROUP BY u.id
+                ORDER BY u.created_at DESC
+                LIMIT ? OFFSET ?
+            """, (per_page, offset))
+            
+            users = cursor.fetchall()
+            
+            # Get total count
+            cursor.execute("SELECT COUNT(*) FROM users")
+            total_users = cursor.fetchone()[0]
+            
+            conn.close()
+            
+            return {
+                'users': [
+                    {
+                        'id': user[0],
+                        'email': user[1],
+                        'created_at': user[2],
+                        'email_confirmed': bool(user[3]),
+                        'last_login': user[4],
+                        'session_count': user[5],
+                        'flashcard_count': user[6],
+                        'article_count': user[7]
+                    } for user in users
+                ],
+                'total': total_users,
+                'page': page,
+                'per_page': per_page,
+                'total_pages': (total_users + per_page - 1) // per_page
+            }
+        except Exception as e:
+            logger.error(f"Error getting users: {e}")
+            return {'users': [], 'total': 0}
+    
+    def delete_user(self, user_id):
+        """Delete a user and all associated data"""
+        try:
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            
+            # Delete in order to respect foreign key constraints
+            tables = [
+                'study_plan_activities', 'study_plans', 'user_analytics',
+                'content_recommendations', 'user_interests', 'user_articles',
+                'study_sessions', 'flashcards', 'user_settings', 'users'
+            ]
+            
+            for table in tables:
+                cursor.execute(f"DELETE FROM {table} WHERE user_id = ?", (user_id,))
+            
+            conn.commit()
+            conn.close()
+            
+            return True
+        except Exception as e:
+            logger.error(f"Error deleting user {user_id}: {e}")
+            return False
+    
+    def get_user_details(self, user_id):
+        """Get detailed information about a specific user"""
+        try:
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            
+            # Basic user info
+            cursor.execute("SELECT * FROM users WHERE id = ?", (user_id,))
+            user = cursor.fetchone()
+            
+            if not user:
+                return None
+            
+            # User settings
+            cursor.execute("SELECT * FROM user_settings WHERE user_id = ?", (user_id,))
+            settings = cursor.fetchone()
+            
+            # Recent activity
+            cursor.execute("""
+                SELECT activity_type, created_at, duration_minutes 
+                FROM study_sessions 
+                WHERE user_id = ? 
+                ORDER BY created_at DESC 
+                LIMIT 20
+            """, (user_id,))
+            recent_sessions = cursor.fetchall()
+            
+            # Token usage
+            cursor.execute("""
+                SELECT api_provider, SUM(input_tokens), SUM(output_tokens), COUNT(*)
+                FROM token_usage 
+                WHERE user_id = ? 
+                GROUP BY api_provider
+            """, (user_id,))
+            token_usage = cursor.fetchall()
+            
+            conn.close()
+            
+            return {
+                'user': {
+                    'id': user[0],
+                    'email': user[1],
+                    'created_at': user[2],
+                    'email_confirmed': bool(user[3]),
+                    'last_login': user[4]
+                },
+                'settings': dict(zip([col[0] for col in cursor.description], settings)) if settings else {},
+                'recent_sessions': [
+                    {
+                        'activity': session[0],
+                        'timestamp': session[1],
+                        'duration': session[2]
+                    } for session in recent_sessions
+                ],
+                'token_usage': [
+                    {
+                        'provider': usage[0],
+                        'input_tokens': usage[1],
+                        'output_tokens': usage[2],
+                        'calls': usage[3]
+                    } for usage in token_usage
+                ]
+            }
+        except Exception as e:
+            logger.error(f"Error getting user details for {user_id}: {e}")
+            return None
+    
+    def record_token_usage(self, user_id, api_provider, input_tokens, output_tokens, operation_type):
+        """Record token usage for cost tracking"""
+        try:
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            
+            cursor.execute("""
+                INSERT INTO token_usage 
+                (user_id, api_provider, input_tokens, output_tokens, operation_type, created_at)
+                VALUES (?, ?, ?, ?, ?, ?)
+            """, (user_id, api_provider, input_tokens, output_tokens, operation_type, datetime.now().isoformat()))
+            
+            conn.commit()
+            conn.close()
+            
+            return True
+        except Exception as e:
+            logger.error(f"Error recording token usage: {e}")
+            return False
+    
+    def get_database_schema(self):
+        """Get database schema information"""
+        try:
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            
+            # Get all tables
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
+            tables = cursor.fetchall()
+            
+            schema_info = {}
+            for table in tables:
+                table_name = table[0]
+                
+                # Get table info
+                cursor.execute(f"PRAGMA table_info({table_name})")
+                columns = cursor.fetchall()
+                
+                # Get row count
+                cursor.execute(f"SELECT COUNT(*) FROM {table_name}")
+                row_count = cursor.fetchone()[0]
+                
+                schema_info[table_name] = {
+                    'columns': [
+                        {
+                            'name': col[1],
+                            'type': col[2],
+                            'not_null': bool(col[3]),
+                            'primary_key': bool(col[5])
+                        } for col in columns
+                    ],
+                    'row_count': row_count
+                }
+            
+            conn.close()
+            return schema_info
+        except Exception as e:
+            logger.error(f"Error getting database schema: {e}")
+            return {}
+    
+    def get_system_health(self):
+        """Get system health metrics"""
+        try:
+            import psutil
+            import os
+            
+            # Memory usage
+            memory = psutil.virtual_memory()
+            
+            # Disk usage
+            disk = psutil.disk_usage('/')
+            
+            # Database size
+            db_path = 'data/englishhelper.db'
+            db_size = os.path.getsize(db_path) if os.path.exists(db_path) else 0
+            
+            # Recent error logs (would implement proper logging)
+            recent_errors = self._get_recent_errors()
+            
+            return {
+                'memory': {
+                    'total': memory.total,
+                    'used': memory.used,
+                    'available': memory.available,
+                    'percent': memory.percent
+                },
+                'disk': {
+                    'total': disk.total,
+                    'used': disk.used,
+                    'free': disk.free,
+                    'percent': disk.percent
+                },
+                'database': {
+                    'size_bytes': db_size,
+                    'size_mb': round(db_size / 1024 / 1024, 2)
+                },
+                'recent_errors': recent_errors,
+                'uptime': self._get_uptime()
+            }
+        except Exception as e:
+            logger.error(f"Error getting system health: {e}")
+            return {}
+    
+    def _get_recent_errors(self):
+        """Get recent error logs (simplified)"""
+        try:
+            # This would typically read from log files
+            # For now, return sample data
+            return [
+                {
+                    'timestamp': '2024-10-11 14:30:00',
+                    'level': 'ERROR',
+                    'message': 'API rate limit exceeded for user 123',
+                    'module': 'groq_client'
+                },
+                {
+                    'timestamp': '2024-10-11 13:45:00',
+                    'level': 'WARNING',
+                    'message': 'High memory usage detected',
+                    'module': 'system_monitor'
+                }
+            ]
+        except:
+            return []
+    
+    def _get_uptime(self):
+        """Get system uptime"""
+        try:
+            import psutil
+            boot_time = psutil.boot_time()
+            uptime_seconds = datetime.now().timestamp() - boot_time
+            
+            days = int(uptime_seconds // 86400)
+            hours = int((uptime_seconds % 86400) // 3600)
+            minutes = int((uptime_seconds % 3600) // 60)
+            
+            return f"{days}d {hours}h {minutes}m"
+        except:
+            return "Unknown"
+    
+    def check_system_alerts(self):
+        """Check for system alerts and warnings"""
+        alerts = []
+        
+        try:
+            # Check token usage limits
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            
+            # Check daily token usage
+            cursor.execute("""
+                SELECT SUM(tokens_used) 
+                FROM token_usage 
+                WHERE date(created_at) = date('now')
+            """)
+            daily_tokens = cursor.fetchone()[0] or 0
+            
+            if daily_tokens > 100000:  # Alert threshold
+                alerts.append({
+                    'type': 'warning',
+                    'message': f'High daily token usage: {daily_tokens:,} tokens',
+                    'action': 'Monitor API costs'
+                })
+            
+            # Check error rates
+            cursor.execute("""
+                SELECT COUNT(*) FROM token_usage 
+                WHERE created_at > datetime('now', '-1 hour')
+            """)
+            hourly_requests = cursor.fetchone()[0] or 0
+            
+            if hourly_requests > 500:  # High load threshold
+                alerts.append({
+                    'type': 'info',
+                    'message': f'High API request rate: {hourly_requests} requests/hour',
+                    'action': 'Monitor performance'
+                })
+            
+            # Check database size
+            health = self.get_system_health()
+            if health.get('database', {}).get('size_mb', 0) > 100:  # 100MB threshold
+                alerts.append({
+                    'type': 'warning',
+                    'message': f'Large database size: {health["database"]["size_mb"]}MB',
+                    'action': 'Consider archiving old data'
+                })
+            
+            conn.close()
+            return alerts
+            
+        except Exception as e:
+            logger.error(f"Error checking system alerts: {e}")
+            return []
+
+# Decorator for admin-only routes
+def admin_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if not admin_manager.is_admin_logged_in():
+            return jsonify({'error': 'Admin authentication required'}), 401
+        return f(*args, **kwargs)
+    return decorated_function
+
+# Global admin manager instance
+admin_manager = AdminManager()

app.py

@@ -0,0 +1,1247 @@
+#app.py
+import os
+import io
+import json
+import base64
+from datetime import datetime
+from PIL import Image
+from email_validator import validate_email, EmailNotValidError
+
+from flask import Flask, request, jsonify, send_file, session, render_template_string, redirect, url_for, Response
+from flask_session import Session
+from gtts import gTTS
+from groq import Groq
+import google.generativeai as genai
+from google.generativeai.types import GenerationConfig
+
+# Import database functions
+from database import (
+    init_db, close_db, create_user, authenticate_user, confirm_email,
+    get_user_settings, update_user_settings, save_user_flashcard,
+    get_user_flashcards, record_study_session, login_required,
+    get_current_user, send_confirmation_email, save_user_article,
+    get_user_articles, update_user_interests, get_user_interests,
+    create_study_plan, get_user_study_plans, add_study_activity,
+    get_study_activities, record_analytics_metric, get_user_analytics,
+    get_db_connection
+)
+
+# Import content curation and study planner
+from content_curator import content_curator
+from study_planner import study_planner
+from admin_module import admin_manager, admin_required
+
+# --- CONFIGURAÇÃO INICIAL ---
+app = Flask(__name__)
+
+# Configuration for sessions
+app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', 'dev-key-change-in-production')
+app.config['SESSION_TYPE'] = 'filesystem'
+app.config['SESSION_PERMANENT'] = False
+app.config['SESSION_USE_SIGNER'] = True
+app.config['SESSION_KEY_PREFIX'] = 'englishhelper:'
+
+Session(app)
+
+# Initialize database
+def initialize_database():
+    init_db()
+
+# Initialize on startup
+initialize_database()
+
+# Token tracking helper function
+def track_token_usage(user_id, provider, input_tokens, output_tokens, operation):
+    """Helper function to track token usage"""
+    try:
+        admin_manager.record_token_usage(user_id, provider, input_tokens, output_tokens, operation)
+    except Exception as e:
+        print(f"Token tracking error: {e}")
+
+@app.teardown_appcontext
+def close_database(error):
+    close_db(error)
+
+# --- CONFIGURAÇÃO DAS APIS LLM ---
+genai_client = None
+groq_client = None
+
+# 1. Configuração Gemini
+try:
+    GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+    if GEMINI_API_KEY:
+        genai.configure(api_key=GEMINI_API_KEY)
+        genai_client = genai
+    else:
+        print("AVISO: GEMINI_API_KEY não configurada.")
+except Exception as e:
+    genai_client = None
+    print(f"ERRO ao inicializar o cliente Gemini: {e}.")
+
+# 2. Configuração Groq
+try:
+    GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
+    if GROQ_API_KEY:
+        groq_client = Groq(api_key=GROQ_API_KEY)
+    else:
+        print("AVISO: GROQ_API_KEY não configurada.")
+except Exception as e:
+    groq_client = None
+    print(f"ERRO ao inicializar o cliente Groq: {e}.")
+
+
+# --- ROTA PARA LISTAR MODELOS DINAMICAMENTE ---
+@app.route('/list-models')
+def list_models():
+    available_models = []
+    groq_text_models = [
+        "llama-3.1-8b-instant", 
+        "llama-3.3-70b-versatile", 
+        "openai/gpt-oss-120b",
+        "openai/gpt-oss-20b"
+    ]
+    try:
+        if genai_client:
+            for m in genai_client.list_models():
+                if 'generateContent' in m.supported_generation_methods:
+                    model_name = m.name.replace("models/", "")
+                    if "flash" in model_name or "pro" in model_name:
+                         available_models.append({
+                            "value": f"gemini:{model_name}",
+                            "name": m.display_name
+                        })
+        if groq_client:
+            for model_id in groq_text_models:
+                 display_name = model_id.split('/')[-1].replace('-instant', '').replace('-versatile', '')
+                 available_models.append({
+                    "value": f"groq:{model_id}",
+                    "name": f"Groq: {display_name}"
+                })
+    except Exception as e:
+        print(f"Erro ao listar modelos: {e}")
+        return jsonify([
+            {"value": "gemini:gemini-2.5-flash-latest", "name": "Gemini 2.5 Flash (Fallback)"},
+            {"value": "groq:llama-3.1-8b-instant", "name": "Llama 3.1 8B (Fallback)"}
+        ])
+    return jsonify(available_models)
+
+
+# --- ROTAS PRINCIPAIS ---
+
+@app.route('/tts-proxy', methods=['POST'])
+def tts_proxy():
+    data = request.get_json()
+    text = data.get('text', '')
+    tld = data.get('tld', 'co.uk') 
+    if not text: return jsonify({"error": "No text provided"}), 400
+    try:
+        tts = gTTS(text=text, lang='en', tld=tld)
+        mp3_fp = io.BytesIO()
+        tts.write_to_fp(mp3_fp)
+        mp3_fp.seek(0)
+        return send_file(mp3_fp, mimetype='audio/mpeg')
+    except Exception as e:
+        return jsonify({"error": f"Failed to generate audio via gTTS: {e}"}), 500
+
+@app.route('/explain-proxy', methods=['POST'])
+def explain_proxy():
+    data = request.get_json()
+    model_provider, model_name = data.get('model', 'gemini:gemini-2.5-flash-latest').split(':', 1)
+    context_focus = data.get('context_focus', 'General/Social')
+    custom_prompt = data.get('custom_prompt', None)
+    word = data.get('word', '').strip()
+    context = data.get('context', '')
+    for_flashcard = data.get('for_flashcard', False)
+
+    if (model_provider == 'gemini' and not genai_client) or (model_provider == 'groq' and not groq_client):
+        return jsonify({"error": f"{model_provider.upper()}_API_KEY not configured."}), 503
+    
+    system_instruction_base = f"You are a professional English tutor. The user's study focus is '{context_focus}'. All your responses must be in ENGLISH."
+    try:
+        if custom_prompt:
+            activity_text = get_ai_text_response(model_provider, model_name, system_instruction_base, custom_prompt)
+            return jsonify({"explanation": activity_text})
+        
+        if not word: return jsonify({"error": "No word selected."}), 400
+        
+        if for_flashcard:
+            schema = {"type": "object", "properties": {"term": {"type": "string"}, "translation": {"type": "string"}, "context_sentence": {"type": "string"}, "gapped_sentence": {"type": "string"}, "definition": {"type": "string"}}, "required": ["term", "translation", "context_sentence", "gapped_sentence", "definition"]}
+            prompt = f"Analyze '{word}' in context: '{context}'. Generate a JSON for a flashcard. The 'gapped_sentence' must replace '{word}' with '______________'."
+            return jsonify(get_ai_text_response(model_provider, model_name, system_instruction_base, prompt, json_schema=schema))
+        else:
+            prompt = f"Analyze '{word}' in context: '{context}'. Provide a one-sentence English explanation, then '---', then the Portuguese translation."
+            parts = get_ai_text_response(model_provider, model_name, system_instruction_base, prompt).split('---', 1)
+            return jsonify({"explanation": parts[0].strip(), "translation": parts[1].strip() if len(parts) > 1 else 'N/A'})
+    except Exception as e:
+        print(f"AI ANALYSIS ERROR in /explain-proxy: {e}")
+        return jsonify({"error": f"AI analysis failed: {e}"}), 500
+
+@app.route('/activity-feedback', methods=['POST'])
+def activity_feedback():
+    data = request.get_json()
+    model_provider, model_name = data.get('model', 'gemini:gemini-2.5-flash-latest').split(':', 1)
+    context_focus = data.get('context_focus', 'General/Social')
+    original_prompt = data.get('original_prompt', '')
+    user_response = data.get('user_response', '')
+
+    if not original_prompt or not user_response: return jsonify({"error": "Original prompt and user response are required."}), 400
+    if (model_provider == 'gemini' and not genai_client) or (model_provider == 'groq' and not groq_client):
+        return jsonify({"error": f"{model_provider.upper()}_API_KEY not configured."}), 503
+
+    system_instruction = (
+        "You are an expert English teacher providing feedback. "
+        f"The user's study focus is '{context_focus}'. "
+        "Your entire response MUST be in English. "
+        "Provide clear, constructive feedback on the user's writing. "
+        "Point out grammar, spelling, or style errors. "
+        "Offer a corrected or improved version of their text. "
+        "Structure your feedback with markdown for clarity (e.g., using ### Corrected Version)."
+    )
+    user_prompt = f"The original task was: \"{original_prompt}\"\n\nHere is the user's response:\n---\n{user_response}\n---\nPlease provide your feedback."
+    try:
+        feedback_text = get_ai_text_response(model_provider, model_name, system_instruction, user_prompt)
+        return jsonify({"feedback": feedback_text})
+    except Exception as e:
+        return jsonify({"error": f"AI feedback failed: {e}"}), 500
+
+@app.route('/analyze-image', methods=['POST'])
+def analyze_image():
+    if not genai_client: return jsonify({"error": "GEMINI_API_KEY not configured."}), 503
+    data = request.get_json()
+    base64_image = data.get('image')
+    model_value = data.get('model', 'gemini:gemini-2.5-flash-latest')
+    
+    model_name = 'gemini-2.5-flash-latest' # Default
+    if model_value.startswith('gemini:'):
+        model_name = model_value.split(':', 1)[1]
+
+    if not base64_image: return jsonify({"error": "No image data."}), 400
+    try:
+        image = Image.open(io.BytesIO(base64.b64decode(base64_image.split(',')[1])))
+        model = genai_client.GenerativeModel(model_name)
+        schema = { "type": "object", "properties": { "vocabulary": { "type": "array", "items": { "type": "object", "properties": { "term": {"type": "string"}, "definition": {"type": "string"} }, "required": ["term", "definition"] } } }, "required": ["vocabulary"] }
+        prompt = [ "Act as an English teacher. Identify 5-7 key objects/concepts in this image. For each, provide its English name and a simple definition. Return a single JSON object conforming to the schema.", image ]
+        
+        config = GenerationConfig(response_mime_type="application/json", response_schema=schema)
+        response = model.generate_content(prompt, generation_config=config)
+        
+        return jsonify(json.loads(response.text)['vocabulary'])
+    except Exception as e:
+        return jsonify({"error": f"Image analysis failed: {e}"}), 500
+
+@app.route('/chat-with-ai', methods=['POST'])
+def chat_with_ai():
+    if not groq_client: return jsonify({"error": "GROQ_API_KEY not configured."}), 503
+    data = request.get_json()
+    history, user_message = data.get('history', []), data.get('message', '')
+    if not user_message: return jsonify({"error": "No message."}), 400
+    try:
+        system = "You are 'Groq Chat', a friendly English tutor. Keep responses concise (1-2 sentences). If the user makes a grammar mistake, gently correct it. Ask questions to keep the conversation flowing. Always respond in English."
+        messages = [{"role": "system", "content": system}] + history + [{"role": "user", "content": user_message}]
+        response = groq_client.chat.completions.create(model="llama-3.1-8b-instant", messages=messages, temperature=0.7)
+        
+        # Track token usage
+        user = get_current_user()
+        if user and hasattr(response, 'usage'):
+            track_token_usage(
+                user['id'], 
+                'groq', 
+                response.usage.prompt_tokens, 
+                response.usage.completion_tokens, 
+                'conversation'
+            )
+        
+        return jsonify({"response": response.choices[0].message.content.strip()})
+    except Exception as e:
+        return jsonify({"error": f"AI chat failed: {e}"}), 500
+
+@app.route('/pronunciation-feedback', methods=['POST'])
+def pronunciation_feedback():
+    if not groq_client: return jsonify({"error": "GROQ_API_KEY not configured."}), 503
+    data = request.get_json()
+    target_text, user_text = data.get('target_text'), data.get('user_text')
+    if not target_text or not user_text: return jsonify({"error": "Required data missing."}), 400
+    try:
+        system_instruction = "You are an expert American English pronunciation coach. The user tried to say a target sentence, and their speech was transcribed. Based on the likely pronunciation differences, provide brief, friendly, and actionable feedback in Portuguese. Focus on 1-2 key points. If it's very close, praise the user."
+        user_prompt = f"Target: \"{target_text}\"\nTranscription: \"{user_text}\"\n\nProvide pronunciation feedback."
+        messages = [{"role": "system", "content": system_instruction}, {"role": "user", "content": user_prompt}]
+        response = groq_client.chat.completions.create(model="llama-3.1-8b-instant", messages=messages, temperature=0.5)
+        
+        # Track token usage
+        user = get_current_user()
+        if user and hasattr(response, 'usage'):
+            track_token_usage(
+                user['id'], 
+                'groq', 
+                response.usage.prompt_tokens, 
+                response.usage.completion_tokens, 
+                'pronunciation_feedback'
+            )
+        
+        return jsonify({"feedback": response.choices[0].message.content.strip()})
+    except Exception as e:
+        return jsonify({"error": f"Pronunciation analysis failed: {e}"}), 500
+
+@app.route('/generate-image', methods=['POST'])
+def generate_image():
+    if not genai_client: return jsonify({"error": "GEMINI_API_KEY not configured."}), 503
+    data = request.get_json()
+    prompt = data.get('prompt')
+    if not prompt: return jsonify({"error": "Image prompt is required."}), 400
+    try:
+        model = genai_client.GenerativeModel(model_name='gemini-2.5-flash-image-preview')
+        response = model.generate_content(prompt)
+        base64_image_data = response.parts[0].inline_data.data
+        return jsonify({"image_base64": base64_image_data})
+    except Exception as e:
+        return jsonify({"error": f"Image generation failed: {e}"}), 500
+
+# --- FUNÇÃO AUXILIAR E ROTA RAIZ ---
+def get_ai_text_response(provider, model_name, system_instruction, user_prompt, json_schema=None):
+    if provider == 'gemini':
+        model = genai_client.GenerativeModel(model_name, system_instruction=system_instruction)
+        
+        config = None
+        if json_schema:
+            config = GenerationConfig(response_mime_type="application/json", response_schema=json_schema)
+        
+        response = model.generate_content(user_prompt, generation_config=config)
+        
+        if json_schema:
+            parsed_json = json.loads(response.text)
+            required_keys = json_schema.get("required", [])
+            if not all(key in parsed_json and parsed_json[key] for key in required_keys):
+                raise ValueError(f"AI response missing required keys or has empty values.")
+            return parsed_json
+        else:
+            return response.text.strip()
+
+    elif provider == 'groq':
+        final_user_prompt = user_prompt
+        if json_schema:
+             final_user_prompt += f"\n\nYou MUST respond with a single JSON object that strictly follows this schema. Do not add any other text before or after the JSON object:\n{json.dumps(json_schema)}"
+        
+        messages = [{"role": "system", "content": system_instruction}, {"role": "user", "content": final_user_prompt}]
+        config = {'response_format': {"type": "json_object"}} if json_schema else {}
+        response = groq_client.chat.completions.create(model=model_name, messages=messages, **config)
+        
+        if json_schema:
+            parsed_json = json.loads(response.choices[0].message.content)
+            required_keys = json_schema.get("required", [])
+            if not all(key in parsed_json and parsed_json[key] for key in required_keys):
+                raise ValueError(f"AI response missing required keys or has empty values.")
+            return parsed_json
+        else:
+            return response.choices[0].message.content.strip()
+
+    raise Exception(f"Unsupported provider: {provider}")
+
+# --- AUTHENTICATION ROUTES ---
+
+@app.route('/register', methods=['POST'])
+def register():
+    """User registration endpoint"""
+    try:
+        data = request.get_json()
+        email = data.get('email', '').strip().lower()
+        password = data.get('password', '')
+        
+        # Validate input
+        if not email or not password:
+            return jsonify({'error': 'Email and password are required'}), 400
+        
+        if len(password) < 8:
+            return jsonify({'error': 'Password must be at least 8 characters long'}), 400
+        
+        # Validate email format
+        try:
+            validate_email(email)
+        except EmailNotValidError:
+            return jsonify({'error': 'Invalid email format'}), 400
+        
+        # Create user
+        result = create_user(email, password)
+        
+        if result['success']:
+            # Send confirmation email
+            if send_confirmation_email(email, result['confirmation_token']):
+                return jsonify({
+                    'message': 'Registration successful! Please check your email to confirm your account.',
+                    'email_sent': True
+                }), 201
+            else:
+                return jsonify({
+                    'message': 'Registration successful! However, we could not send the confirmation email. Please contact support.',
+                    'email_sent': False
+                }), 201
+        else:
+            return jsonify({'error': result['message']}), 400
+            
+    except Exception as e:
+        print(f"Registration error: {e}")
+        return jsonify({'error': 'Internal server error'}), 500
+
+@app.route('/login', methods=['POST'])
+def login():
+    """User login endpoint"""
+    try:
+        data = request.get_json()
+        email = data.get('email', '').strip().lower()
+        password = data.get('password', '')
+        
+        if not email or not password:
+            return jsonify({'error': 'Email and password are required'}), 400
+        
+        result = authenticate_user(email, password)
+        
+        if result['success']:
+            session['user_id'] = result['user_id']
+            session['user_email'] = result['email']
+            session.permanent = True
+            
+            # Get user settings
+            settings = get_user_settings(result['user_id'])
+            
+            return jsonify({
+                'message': 'Login successful',
+                'user': {
+                    'id': result['user_id'],
+                    'email': result['email'],
+                    'settings': settings
+                }
+            }), 200
+        else:
+            return jsonify({'error': result['message']}), 401
+            
+    except Exception as e:
+        print(f"Login error: {e}")
+        return jsonify({'error': 'Internal server error'}), 500
+
+@app.route('/logout', methods=['POST'])
+def logout():
+    """User logout endpoint"""
+    session.clear()
+    return jsonify({'message': 'Logout successful'}), 200
+
+@app.route('/confirm-email')
+def confirm_email_route():
+    """Email confirmation endpoint"""
+    token = request.args.get('token')
+    
+    if not token:
+        return render_template_string('''
+        <!DOCTYPE html>
+        <html><head><title>Invalid Link</title></head>
+        <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
+            <h2>Invalid Confirmation Link</h2>
+            <p>This confirmation link is invalid or malformed.</p>
+            <a href="/" style="color: #4f46e5;">Return to English Helper</a>
+        </body></html>
+        '''), 400
+    
+    result = confirm_email(token)
+    
+    if result['success']:
+        return render_template_string('''
+        <!DOCTYPE html>
+        <html><head><title>Email Confirmed</title></head>
+        <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
+            <h2>✅ Email Confirmed!</h2>
+            <p>Your email has been successfully confirmed. You can now log in to your account.</p>
+            <a href="/" style="background: #4f46e5; color: white; padding: 10px 20px; text-decoration: none; border-radius: 5px;">Continue to English Helper</a>
+        </body></html>
+        ''')
+    else:
+        return render_template_string('''
+        <!DOCTYPE html>
+        <html><head><title>Confirmation Failed</title></head>
+        <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
+            <h2>❌ Confirmation Failed</h2>
+            <p>This confirmation link is invalid or has expired.</p>
+            <a href="/" style="color: #4f46e5;">Return to English Helper</a>
+        </body></html>
+        '''), 400
+
+@app.route('/user/profile', methods=['GET'])
+@login_required
+def get_user_profile():
+    """Get current user profile"""
+    user = get_current_user()
+    if not user:
+        return jsonify({'error': 'User not found'}), 404
+    
+    settings = get_user_settings(user['id'])
+    flashcards_count = len(get_user_flashcards(user['id'], 1000))
+    
+    return jsonify({
+        'user': {
+            'id': user['id'],
+            'email': user['email'],
+            'settings': settings,
+            'stats': {
+                'flashcards_created': flashcards_count
+            }
+        }
+    })
+
+@app.route('/user/settings', methods=['GET', 'POST'])
+@login_required
+def user_settings():
+    """Get or update user settings"""
+    user = get_current_user()
+    if not user:
+        return jsonify({'error': 'User not found'}), 404
+    
+    if request.method == 'GET':
+        settings = get_user_settings(user['id'])
+        return jsonify({'settings': settings})
+    
+    elif request.method == 'POST':
+        data = request.get_json()
+        settings = {
+            'preferred_model': data.get('preferred_model'),
+            'context_focus': data.get('context_focus'),
+            'voice_accent': data.get('voice_accent'),
+            'daily_goal': data.get('daily_goal', 10),
+            'notification_enabled': data.get('notification_enabled', True)
+        }
+        
+        if update_user_settings(user['id'], settings):
+            return jsonify({'message': 'Settings updated successfully'})
+        else:
+            return jsonify({'error': 'Failed to update settings'}), 500
+
+@app.route('/user/flashcards', methods=['GET', 'POST'])
+@login_required
+def user_flashcards():
+    """Get user flashcards or save new flashcard"""
+    user = get_current_user()
+    if not user:
+        return jsonify({'error': 'User not found'}), 404
+    
+    if request.method == 'GET':
+        flashcards = get_user_flashcards(user['id'])
+        return jsonify({'flashcards': flashcards})
+    
+    elif request.method == 'POST':
+        data = request.get_json()
+        if save_user_flashcard(user['id'], data):
+            return jsonify({'message': 'Flashcard saved successfully'})
+        else:
+            return jsonify({'error': 'Failed to save flashcard'}), 500
+
+@app.route('/auth/check', methods=['GET'])
+def check_auth():
+    """Check if user is authenticated"""
+    user = get_current_user()
+    if user:
+        settings = get_user_settings(user['id'])
+        return jsonify({
+            'authenticated': True,
+            'user': {
+                'id': user['id'],
+                'email': user['email'],
+                'settings': settings
+            }
+        })
+    else:
+        return jsonify({'authenticated': False})
+
+# --- MODIFIED EXISTING ROUTES TO SUPPORT USER DATA ---
+
+# Override the original explain-proxy to save flashcards for logged-in users
+@app.route('/explain-proxy', methods=['POST'])
+def explain_proxy():
+    data = request.get_json()
+    model_provider, model_name = data.get('model', 'gemini:gemini-2.5-flash-latest').split(':', 1)
+    context_focus = data.get('context_focus', 'General/Social')
+    custom_prompt = data.get('custom_prompt', None)
+    word = data.get('word', '').strip()
+    context = data.get('context', '')
+    for_flashcard = data.get('for_flashcard', False)
+
+    if (model_provider == 'gemini' and not genai_client) or (model_provider == 'groq' and not groq_client):
+        return jsonify({"error": f"{model_provider.upper()}_API_KEY not configured."}), 503
+    
+    system_instruction_base = f"You are a professional English tutor. The user's study focus is '{context_focus}'. All your responses must be in ENGLISH."
+    try:
+        if custom_prompt:
+            activity_text = get_ai_text_response(model_provider, model_name, system_instruction_base, custom_prompt)
+            return jsonify({"explanation": activity_text})
+        
+        if not word: return jsonify({"error": "No word selected."}), 400
+        
+        if for_flashcard:
+            schema = {"type": "object", "properties": {"term": {"type": "string"}, "translation": {"type": "string"}, "context_sentence": {"type": "string"}, "gapped_sentence": {"type": "string"}, "definition": {"type": "string"}}, "required": ["term", "translation", "context_sentence", "gapped_sentence", "definition"]}
+            prompt = f"Analyze '{word}' in context: '{context}'. Generate a JSON for a flashcard. The 'gapped_sentence' must replace '{word}' with '______________'."
+            flashcard_data = get_ai_text_response(model_provider, model_name, system_instruction_base, prompt, json_schema=schema)
+            
+            # Save flashcard for logged-in users
+            user = get_current_user()
+            if user:
+                save_user_flashcard(user['id'], flashcard_data)
+            
+            return jsonify(flashcard_data)
+        else:
+            prompt = f"Analyze '{word}' in context: '{context}'. Provide a one-sentence English explanation, then '---', then the Portuguese translation."
+            parts = get_ai_text_response(model_provider, model_name, system_instruction_base, prompt).split('---', 1)
+            return jsonify({"explanation": parts[0].strip(), "translation": parts[1].strip() if len(parts) > 1 else 'N/A'})
+    except Exception as e:
+        print(f"AI ANALYSIS ERROR in /explain-proxy: {e}")
+        return jsonify({"error": f"AI analysis failed: {e}"}), 500
+
+# --- CONTENT CURATION ROUTES ---
+
+@app.route('/content/search', methods=['POST'])
+@login_required
+def search_content():
+    """Search for content based on user interests"""
+    try:
+        user = get_current_user()
+        if not user:
+            return jsonify({'error': 'User not found'}), 404
+        
+        data = request.get_json()
+        query = data.get('query', '')
+        category = data.get('category', '')
+        
+        # Get user settings and interests
+        settings = get_user_settings(user['id'])
+        interests = get_user_interests(user['id'])
+        
+        if not interests and query:
+            # Use query as interest if no interests set
+            interests = {query: 1.0}
+        
+        english_level = settings.get('english_level', 'B1') if settings else 'B1'
+        context_focus = settings.get('context_focus', 'General/Social') if settings else 'General/Social'
+        
+        # Search for content
+        results = content_curator.search_content(
+            interests=list(interests.keys()) if interests else [query],
+            english_level=english_level,
+            context_focus=context_focus,
+            limit=10
+        )
+        
+        return jsonify({'results': results})
+        
+    except Exception as e:
+        print(f"Content search error: {e}")
+        return jsonify({'error': 'Content search failed'}), 500
+
+@app.route('/content/extract', methods=['POST'])
+@login_required
+def extract_content():
+    """Extract content from URL"""
+    try:
+        data = request.get_json()
+        url = data.get('url', '')
+        
+        if not url:
+            return jsonify({'error': 'URL required'}), 400
+        
+        result = content_curator.extract_content_from_url(url)
+        return jsonify(result)
+        
+    except Exception as e:
+        print(f"Content extraction error: {e}")
+        return jsonify({'error': 'Content extraction failed'}), 500
+
+@app.route('/content/save', methods=['POST'])
+@login_required
+def save_content():
+    """Save content/article for user"""
+    try:
+        user = get_current_user()
+        if not user:
+            return jsonify({'error': 'User not found'}), 404
+        
+        data = request.get_json()
+        title = data.get('title', '')
+        content = data.get('content', '')
+        source_url = data.get('source_url')
+        source_type = data.get('source_type', 'manual')
+        category = data.get('category')
+        
+        if not title or not content:
+            return jsonify({'error': 'Title and content required'}), 400
+        
+        result = save_user_article(user['id'], title, content, source_url, source_type, category)
+        
+        if result['success']:
+            # Record analytics
+            record_analytics_metric(user['id'], 'content_saved', 1)
+            return jsonify({'message': 'Content saved successfully', 'article_id': result['article_id']})
+        else:
+            return jsonify({'error': result['message']}), 500
+        
+    except Exception as e:
+        print(f"Save content error: {e}")
+        return jsonify({'error': 'Failed to save content'}), 500
+
+@app.route('/content/articles', methods=['GET'])
+@login_required
+def get_articles():
+    """Get user's saved articles"""
+    try:
+        user = get_current_user()
+        if not user:
+            return jsonify({'error': 'User not found'}), 404
+        
+        category = request.args.get('category')
+        limit = int(request.args.get('limit', 50))
+        
+        articles = get_user_articles(user['id'], category, limit)
+        return jsonify({'articles': articles})
+        
+    except Exception as e:
+        print(f"Get articles error: {e}")
+        return jsonify({'error': 'Failed to get articles'}), 500
+
+@app.route('/content/interests', methods=['GET', 'POST'])
+@login_required
+def manage_interests():
+    """Get or update user interests"""
+    try:
+        user = get_current_user()
+        if not user:
+            return jsonify({'error': 'User not found'}), 404
+        
+        if request.method == 'GET':
+            interests = get_user_interests(user['id'])
+            return jsonify({'interests': interests})
+        
+        elif request.method == 'POST':
+            data = request.get_json()
+            interests = data.get('interests', {})
+            
+            if update_user_interests(user['id'], interests):
+                return jsonify({'message': 'Interests updated successfully'})
+            else:
+                return jsonify({'error': 'Failed to update interests'}), 500
+        
+    except Exception as e:
+        print(f"Manage interests error: {e}")
+        return jsonify({'error': 'Failed to manage interests'}), 500
+
+@app.route('/content/recommendations', methods=['GET'])
+@login_required
+def get_recommendations():
+    """Get AI-powered content recommendations"""
+    try:
+        user = get_current_user()
+        if not user:
+            return jsonify({'error': 'User not found'}), 404
+        
+        # Get user data
+        interests = get_user_interests(user['id'])
+        recent_articles = get_user_articles(user['id'], limit=10)
+        settings = get_user_settings(user['id'])
+        
+        english_level = settings.get('english_level', 'B1') if settings else 'B1'
+        context_focus = settings.get('context_focus', 'General/Social') if settings else 'General/Social'
+        
+        # Generate recommendations
+        recommendations = content_curator.generate_personalized_recommendations(
+            interests, recent_articles, english_level, context_focus, user['id']
+        )
+        
+        return jsonify({'recommendations': recommendations})
+        
+    except Exception as e:
+        print(f"Recommendations error: {e}")
+        return jsonify({'error': 'Failed to get recommendations'}), 500
+
+@app.route('/content/analyze', methods=['POST'])
+@login_required
+def analyze_content():
+    """Analyze content for learning insights"""
+    try:
+        user = get_current_user()
+        if not user:
+            return jsonify({'error': 'User not found'}), 404
+        
+        data = request.get_json()
+        content = data.get('content', '')
+        
+        if not content:
+            return jsonify({'error': 'Content required'}), 400
+        
+        settings = get_user_settings(user['id'])
+        english_level = settings.get('english_level', 'B1') if settings else 'B1'
+        
+        analysis = content_curator.analyze_content_for_learning(content, english_level)
+        
+        return jsonify({'analysis': analysis})
+        
+    except Exception as e:
+        print(f"Content analysis error: {e}")
+        return jsonify({'error': 'Content analysis failed'}), 500
+
+# --- STUDY PLANNING ROUTES ---
+
+@app.route('/study/plans', methods=['GET', 'POST'])
+@login_required
+def manage_study_plans():
+    """Get or create study plans"""
+    try:
+        user = get_current_user()
+        if not user:
+            return jsonify({'error': 'User not found'}), 404
+        
+        if request.method == 'GET':
+            plans = get_user_study_plans(user['id'])
+            return jsonify({'plans': plans})
+        
+        elif request.method == 'POST':
+            data = request.get_json()
+            plan_name = data.get('plan_name', '')
+            target_level = data.get('target_level', 'B2')
+            current_level = data.get('current_level', 'B1')
+            objectives = json.dumps(data.get('objectives', []))
+            weekly_hours = data.get('weekly_hours', 5)
+            
+            if not plan_name:
+                return jsonify({'error': 'Plan name required'}), 400
+            
+            result = create_study_plan(user['id'], plan_name, target_level, current_level, objectives, weekly_hours)
+            
+            if result['success']:
+                return jsonify({'message': 'Study plan created', 'plan_id': result['plan_id']})
+            else:
+                return jsonify({'error': result['message']}), 500
+        
+    except Exception as e:
+        print(f"Study plans error: {e}")
+        return jsonify({'error': 'Failed to manage study plans'}), 500
+
+@app.route('/analytics/dashboard', methods=['GET'])
+@login_required
+def analytics_dashboard():
+    """Get analytics dashboard data"""
+    try:
+        user = get_current_user()
+        if not user:
+            return jsonify({'error': 'User not found'}), 404
+        
+        days = int(request.args.get('days', 30))
+        
+        # Get various analytics
+        analytics_data = {
+            'flashcards_created': get_user_analytics(user['id'], 'flashcards_created', days),
+            'content_saved': get_user_analytics(user['id'], 'content_saved', days),
+            'study_sessions': get_user_analytics(user['id'], 'study_session', days),
+            'total_flashcards': len(get_user_flashcards(user['id'], 1000)),
+            'total_articles': len(get_user_articles(user['id'], limit=1000)),
+            'user_level': get_user_settings(user['id']).get('english_level', 'B1')
+        }
+        
+        return jsonify({'analytics': analytics_data})
+        
+    except Exception as e:
+        print(f"Analytics error: {e}")
+        return jsonify({'error': 'Failed to get analytics'}), 500
+
+# --- STUDY PLANNER ROUTES ---
+
+@app.route('/study-plan/create', methods=['POST'])
+@login_required
+def create_study_plan_route():
+    """Create a personalized study plan"""
+    try:
+        user = get_current_user()
+        if not user:
+            return jsonify({'error': 'User not found'}), 404
+        
+        data = request.get_json()
+        
+        # Get user settings and interests
+        user_settings = get_user_settings(user['id'])
+        user_interests = get_user_interests(user['id'])
+        
+        # Prepare data for study planner
+        planner_data = {
+            'english_level': data.get('current_level') or user_settings.get('english_level', 'B1'),
+            'target_level': data.get('target_level', 'B2'),
+            'weekly_hours': int(data.get('weekly_hours', 5)),
+            'context_focus': data.get('context_focus') or user_settings.get('context_focus', 'General/Social'),
+            'interests': user_interests,
+            'study_goals': data.get('study_goals', [])
+        }
+        
+        # Generate the plan
+        result = study_planner.generate_personalized_plan(planner_data)
+        
+        if result['success']:
+            plan = result['plan']
+            
+            # Save to database
+            plan_id = create_study_plan(
+                user['id'],
+                plan['target_level'],
+                plan['weekly_hours'],
+                plan['estimated_weeks'],
+                json.dumps(plan)
+            )
+            
+            plan['id'] = plan_id
+            
+            # Record analytics
+            record_analytics_metric(user['id'], 'study_plan_created', 1)
+            
+            return jsonify({'success': True, 'plan': plan})
+        else:
+            return jsonify({'success': False, 'error': result['error']}), 500
+            
+    except Exception as e:
+        print(f"Study plan creation error: {e}")
+        return jsonify({'error': 'Failed to create study plan'}), 500
+
+@app.route('/study-plan/current', methods=['GET'])
+@login_required
+def get_current_study_plan():
+    """Get user's current study plan"""
+    try:
+        user = get_current_user()
+        if not user:
+            return jsonify({'error': 'User not found'}), 404
+        
+        plans = get_user_study_plans(user['id'])
+        
+        if plans:
+            # Get the most recent active plan
+            current_plan = plans[0]  # Assuming most recent first
+            
+            # Parse the plan data
+            plan_data = json.loads(current_plan['plan_data'])
+            
+            # Add database ID
+            plan_data['db_id'] = current_plan['id']
+            
+            # Get activities for this plan
+            activities = get_study_activities(current_plan['id'])
+            plan_data['completed_activities'] = activities
+            
+            return jsonify({'success': True, 'plan': plan_data})
+        else:
+            return jsonify({'success': True, 'plan': None})
+            
+    except Exception as e:
+        print(f"Get study plan error: {e}")
+        return jsonify({'error': 'Failed to get study plan'}), 500
+
+@app.route('/study-plan/activity/complete', methods=['POST'])
+@login_required
+def complete_study_activity():
+    """Mark a study activity as completed"""
+    try:
+        user = get_current_user()
+        if not user:
+            return jsonify({'error': 'User not found'}), 404
+        
+        data = request.get_json()
+        plan_id = data.get('plan_id')
+        activity_id = data.get('activity_id')
+        duration_minutes = data.get('duration_minutes', 0)
+        notes = data.get('notes', '')
+        
+        if not plan_id or not activity_id:
+            return jsonify({'error': 'Missing plan_id or activity_id'}), 400
+        
+        # Add activity completion
+        add_study_activity(plan_id, activity_id, duration_minutes, notes)
+        
+        # Record analytics
+        record_analytics_metric(user['id'], 'study_activity_completed', 1)
+        record_analytics_metric(user['id'], 'study_time_minutes', duration_minutes)
+        
+        return jsonify({'success': True})
+        
+    except Exception as e:
+        print(f"Complete activity error: {e}")
+        return jsonify({'error': 'Failed to complete activity'}), 500
+
+@app.route('/study-plan/progress', methods=['GET'])
+@login_required  
+def get_study_progress():
+    """Get study plan progress analytics"""
+    try:
+        user = get_current_user()
+        if not user:
+            return jsonify({'error': 'User not found'}), 404
+        
+        plans = get_user_study_plans(user['id'])
+        
+        if not plans:
+            return jsonify({'success': True, 'progress': None})
+        
+        current_plan = plans[0]
+        plan_data = json.loads(current_plan['plan_data'])
+        activities = get_study_activities(current_plan['id'])
+        
+        # Calculate progress
+        total_activities = len(plan_data.get('activities', []))
+        completed_activities = len(activities)
+        
+        progress_data = {
+            'total_activities': total_activities,
+            'completed_activities': completed_activities,
+            'completion_percentage': (completed_activities / max(total_activities, 1)) * 100,
+            'estimated_weeks': plan_data.get('estimated_weeks', 0),
+            'weeks_elapsed': max(1, (datetime.now() - datetime.fromisoformat(current_plan['created_at'])).days // 7),
+            'target_level': plan_data.get('target_level', 'B2'),
+            'weekly_hours': plan_data.get('weekly_hours', 5),
+            'recent_activities': activities[-10:] if activities else []  # Last 10 activities
+        }
+        
+        return jsonify({'success': True, 'progress': progress_data})
+        
+    except Exception as e:
+        print(f"Study progress error: {e}")
+        return jsonify({'error': 'Failed to get study progress'}), 500
+
+# --- ADMIN ROUTES ---
+
+@app.route('/admin/login', methods=['POST'])
+def admin_login():
+    """Admin login endpoint"""
+    try:
+        data = request.get_json()
+        username = data.get('username')
+        password = data.get('password')
+        
+        if admin_manager.login_admin(username, password):
+            return jsonify({'success': True, 'message': 'Admin logged in successfully'})
+        else:
+            return jsonify({'success': False, 'error': 'Invalid credentials'}), 401
+            
+    except Exception as e:
+        print(f"Admin login error: {e}")
+        return jsonify({'error': 'Admin login failed'}), 500
+
+@app.route('/admin/logout', methods=['POST'])
+@admin_required
+def admin_logout():
+    """Admin logout endpoint"""
+    try:
+        admin_manager.logout_admin()
+        return jsonify({'success': True, 'message': 'Admin logged out successfully'})
+    except Exception as e:
+        print(f"Admin logout error: {e}")
+        return jsonify({'error': 'Admin logout failed'}), 500
+
+@app.route('/admin/check', methods=['GET'])
+def admin_check():
+    """Check admin authentication status"""
+    try:
+        is_authenticated = admin_manager.is_admin_logged_in()
+        return jsonify({
+            'authenticated': is_authenticated,
+            'username': session.get('admin_username') if is_authenticated else None
+        })
+    except Exception as e:
+        print(f"Admin check error: {e}")
+        return jsonify({'authenticated': False})
+
+@app.route('/admin/dashboard', methods=['GET'])
+@admin_required
+def admin_dashboard():
+    """Get admin dashboard data"""
+    try:
+        stats = admin_manager.get_system_stats()
+        return jsonify({'success': True, 'stats': stats})
+    except Exception as e:
+        print(f"Admin dashboard error: {e}")
+        return jsonify({'error': 'Failed to load dashboard'}), 500
+
+@app.route('/admin/users', methods=['GET'])
+@admin_required
+def admin_get_users():
+    """Get paginated list of users"""
+    try:
+        page = int(request.args.get('page', 1))
+        per_page = int(request.args.get('per_page', 20))
+        
+        users_data = admin_manager.get_all_users(page, per_page)
+        return jsonify({'success': True, 'data': users_data})
+    except Exception as e:
+        print(f"Admin get users error: {e}")
+        return jsonify({'error': 'Failed to get users'}), 500
+
+@app.route('/admin/users/<int:user_id>', methods=['GET'])
+@admin_required
+def admin_get_user_details(user_id):
+    """Get detailed information about a user"""
+    try:
+        user_details = admin_manager.get_user_details(user_id)
+        if user_details:
+            return jsonify({'success': True, 'user': user_details})
+        else:
+            return jsonify({'error': 'User not found'}), 404
+    except Exception as e:
+        print(f"Admin get user details error: {e}")
+        return jsonify({'error': 'Failed to get user details'}), 500
+
+@app.route('/admin/users/<int:user_id>', methods=['DELETE'])
+@admin_required
+def admin_delete_user(user_id):
+    """Delete a user and all associated data"""
+    try:
+        if admin_manager.delete_user(user_id):
+            return jsonify({'success': True, 'message': 'User deleted successfully'})
+        else:
+            return jsonify({'error': 'Failed to delete user'}), 500
+    except Exception as e:
+        print(f"Admin delete user error: {e}")
+        return jsonify({'error': 'Failed to delete user'}), 500
+
+@app.route('/admin/database/schema', methods=['GET'])
+@admin_required
+def admin_get_database_schema():
+    """Get database schema information"""
+    try:
+        schema = admin_manager.get_database_schema()
+        return jsonify({'success': True, 'schema': schema})
+    except Exception as e:
+        print(f"Admin get schema error: {e}")
+        return jsonify({'error': 'Failed to get database schema'}), 500
+
+@app.route('/admin/token-usage', methods=['POST'])
+def record_token_usage():
+    """Record token usage (called by AI functions)"""
+    try:
+        data = request.get_json()
+        user_id = data.get('user_id')
+        api_provider = data.get('api_provider')
+        input_tokens = data.get('input_tokens', 0)
+        output_tokens = data.get('output_tokens', 0)
+        operation_type = data.get('operation_type', 'unknown')
+        
+        admin_manager.record_token_usage(
+            user_id, api_provider, input_tokens, output_tokens, operation_type
+        )
+        
+        return jsonify({'success': True})
+    except Exception as e:
+        print(f"Token usage recording error: {e}")
+        return jsonify({'error': 'Failed to record token usage'}), 500
+
+@app.route('/admin/export/users', methods=['GET'])
+@admin_required
+def export_users():
+    """Export users data as CSV"""
+    try:
+        import csv
+        from io import StringIO
+        
+        users_data = admin_manager.get_all_users(page=1, per_page=10000)  # Get all users
+        
+        output = StringIO()
+        writer = csv.writer(output)
+        
+        # Write header
+        writer.writerow(['ID', 'Email', 'Created At', 'Email Confirmed', 'Last Login', 'Sessions', 'Flashcards', 'Articles'])
+        
+        # Write data
+        for user in users_data['users']:
+            writer.writerow([
+                user['id'],
+                user['email'],
+                user['created_at'],
+                user['email_confirmed'],
+                user['last_login'] or 'Never',
+                user['session_count'],
+                user['flashcard_count'],
+                user['article_count']
+            ])
+        
+        output.seek(0)
+        
+        return Response(
+            output.getvalue(),
+            mimetype='text/csv',
+            headers={'Content-Disposition': f'attachment; filename=users_export_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv'}
+        )
+        
+    except Exception as e:
+        print(f"Export users error: {e}")
+        return jsonify({'error': 'Failed to export users'}), 500
+
+@app.route('/admin/export/tokens', methods=['GET'])
+@admin_required
+def export_token_usage():
+    """Export token usage data as CSV"""
+    try:
+        import csv
+        from io import StringIO
+        
+        conn = get_db_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            SELECT t.created_at, u.email, t.api_provider, t.input_tokens, 
+                   t.output_tokens, t.tokens_used, t.operation_type
+            FROM token_usage t
+            LEFT JOIN users u ON t.user_id = u.id
+            ORDER BY t.created_at DESC
+        """)
+        
+        token_data = cursor.fetchall()
+        conn.close()
+        
+        output = StringIO()
+        writer = csv.writer(output)
+        
+        # Write header
+        writer.writerow(['Date', 'User Email', 'Provider', 'Input Tokens', 'Output Tokens', 'Total Tokens', 'Operation'])
+        
+        # Write data
+        for row in token_data:
+            writer.writerow(row)
+        
+        output.seek(0)
+        
+        return Response(
+            output.getvalue(),
+            mimetype='text/csv',
+            headers={'Content-Disposition': f'attachment; filename=token_usage_export_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv'}
+        )
+        
+    except Exception as e:
+        print(f"Export tokens error: {e}")
+        return jsonify({'error': 'Failed to export token usage'}), 500
+
+@app.route('/admin/system/health', methods=['GET'])
+@admin_required
+def get_system_health():
+    """Get system health metrics"""
+    try:
+        health = admin_manager.get_system_health()
+        return jsonify({'success': True, 'health': health})
+    except Exception as e:
+        print(f"System health error: {e}")
+        return jsonify({'error': 'Failed to get system health'}), 500
+
+@app.route('/admin/system/alerts', methods=['GET'])
+@admin_required
+def get_system_alerts():
+    """Get system alerts"""
+    try:
+        alerts = admin_manager.check_system_alerts()
+        return jsonify({'success': True, 'alerts': alerts})
+    except Exception as e:
+        print(f"System alerts error: {e}")
+        return jsonify({'error': 'Failed to get system alerts'}), 500
+
+@app.route('/admin')
+def admin_interface():
+    """Serve admin interface"""
+    return send_file('admin.html')
+
+@app.route('/')
+def root():
+    return send_file('index.html')
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860)

content_curator.py

@@ -0,0 +1,409 @@
+# content_curator.py
+import requests
+import json
+import re
+from datetime import datetime, timedelta
+from urllib.parse import urlparse, urljoin
+from bs4 import BeautifulSoup
+import feedparser
+import logging
+from groq import Groq
+import google.generativeai as genai
+import os
+
+logger = logging.getLogger(__name__)
+
+# Initialize AI clients
+groq_client = None
+genai_client = None
+
+try:
+    GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
+    if GROQ_API_KEY:
+        groq_client = Groq(api_key=GROQ_API_KEY)
+except Exception as e:
+    logger.warning(f"Groq client not available: {e}")
+
+try:
+    GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+    if GEMINI_API_KEY:
+        genai.configure(api_key=GEMINI_API_KEY)
+        genai_client = genai
+except Exception as e:
+    logger.warning(f"Gemini client not available: {e}")
+
+class ContentCurator:
+    def __init__(self):
+        # Import here to avoid circular imports
+        self.track_tokens = None
+        try:
+            from admin_module import admin_manager
+            self.admin_manager = admin_manager
+        except ImportError:
+            self.admin_manager = None
+    
+    def _track_token_usage(self, user_id, provider, input_tokens, output_tokens, operation):
+        """Track token usage for admin monitoring"""
+        try:
+            if self.admin_manager:
+                self.admin_manager.record_token_usage(user_id, provider, input_tokens, output_tokens, operation)
+        except Exception as e:
+            logger.error(f"Error tracking tokens: {e}")
+    
+        self.search_engines = {
+            # Using free APIs and web scraping
+            'news_sources': {
+                'bbc': 'https://feeds.bbci.co.uk/news/rss.xml',
+                'reuters': 'https://www.reuters.com/arcio/rss/',
+                'techcrunch': 'https://techcrunch.com/feed/',
+                'medium': 'https://medium.com/feed/tag/{topic}',
+            },
+            'content_categories': {
+                'technology': ['tech', 'software', 'AI', 'cybersecurity', 'automotive'],
+                'business': ['business', 'management', 'leadership', 'finance'],
+                'science': ['science', 'research', 'innovation'],
+                'professional': ['career', 'professional-development', 'skills']
+            }
+        }
+    
+    def search_content(self, interests, english_level, context_focus, limit=10):
+        """Search for content based on user interests and level"""
+        try:
+            results = []
+            
+            for interest in interests:
+                # Search RSS feeds
+                rss_results = self._search_rss_feeds(interest, limit=3)
+                results.extend(rss_results)
+                
+                # Search Medium articles
+                medium_results = self._search_medium(interest, limit=2)
+                results.extend(medium_results)
+            
+            # Filter and rank results
+            filtered_results = self._filter_by_level_and_context(
+                results, english_level, context_focus
+            )
+            
+            return filtered_results[:limit]
+            
+        except Exception as e:
+            logger.error(f"Error searching content: {e}")
+            return []
+    
+    def _search_rss_feeds(self, topic, limit=5):
+        """Search RSS feeds for relevant content"""
+        results = []
+        
+        try:
+            # Map topic to appropriate RSS feeds
+            relevant_feeds = []
+            
+            if any(keyword in topic.lower() for keyword in ['tech', 'software', 'cyber', 'adas', 'automotive']):
+                relevant_feeds.extend([
+                    'https://feeds.bbci.co.uk/news/technology/rss.xml',
+                    'https://techcrunch.com/feed/',
+                    'https://www.wired.com/feed/rss'
+                ])
+            
+            if any(keyword in topic.lower() for keyword in ['business', 'management', 'product']):
+                relevant_feeds.extend([
+                    'https://feeds.bbci.co.uk/news/business/rss.xml',
+                    'https://feeds.harvard.edu/news/rss/business.xml'
+                ])
+            
+            # Default to general news if no specific match
+            if not relevant_feeds:
+                relevant_feeds = ['https://feeds.bbci.co.uk/news/rss.xml']
+            
+            for feed_url in relevant_feeds[:2]:  # Limit to 2 feeds to avoid timeout
+                try:
+                    feed = feedparser.parse(feed_url)
+                    
+                    for entry in feed.entries[:limit]:
+                        if self._is_relevant_to_topic(entry.title + " " + entry.get('summary', ''), topic):
+                            results.append({
+                                'title': entry.title,
+                                'url': entry.link,
+                                'summary': entry.get('summary', '')[:200] + '...',
+                                'source': urlparse(feed_url).netloc,
+                                'published': entry.get('published', ''),
+                                'relevance_score': self._calculate_relevance(entry.title, topic)
+                            })
+                
+                except Exception as e:
+                    logger.warning(f"Error parsing feed {feed_url}: {e}")
+                    continue
+        
+        except Exception as e:
+            logger.error(f"Error in RSS search: {e}")
+        
+        return sorted(results, key=lambda x: x['relevance_score'], reverse=True)
+    
+    def _search_medium(self, topic, limit=3):
+        """Search Medium articles (simplified approach)"""
+        results = []
+        
+        try:
+            # Use Medium's RSS feed for topics
+            search_terms = topic.lower().replace(' ', '-')
+            medium_url = f"https://medium.com/feed/tag/{search_terms}"
+            
+            feed = feedparser.parse(medium_url)
+            
+            for entry in feed.entries[:limit]:
+                results.append({
+                    'title': entry.title,
+                    'url': entry.link,
+                    'summary': entry.get('summary', '')[:200] + '...',
+                    'source': 'Medium',
+                    'published': entry.get('published', ''),
+                    'relevance_score': self._calculate_relevance(entry.title, topic)
+                })
+        
+        except Exception as e:
+            logger.warning(f"Error searching Medium: {e}")
+        
+        return results
+    
+    def _is_relevant_to_topic(self, text, topic):
+        """Check if text is relevant to topic"""
+        text_lower = text.lower()
+        topic_words = topic.lower().split()
+        
+        # Simple relevance check
+        matches = sum(1 for word in topic_words if word in text_lower)
+        return matches >= len(topic_words) * 0.5  # At least 50% of topic words present
+    
+    def _calculate_relevance(self, title, topic):
+        """Calculate relevance score between title and topic"""
+        title_lower = title.lower()
+        topic_lower = topic.lower()
+        
+        # Simple scoring based on word matches
+        topic_words = topic_lower.split()
+        score = 0
+        
+        for word in topic_words:
+            if word in title_lower:
+                score += 1
+        
+        return score / len(topic_words) if topic_words else 0
+    
+    def _filter_by_level_and_context(self, results, english_level, context_focus):
+        """Filter results by English level and context"""
+        # Level difficulty mapping
+        level_complexity = {
+            'A1': 1, 'A2': 2, 'B1': 3, 'B2': 4, 'C1': 5, 'C2': 6
+        }
+        
+        user_level = level_complexity.get(english_level, 3)
+        
+        filtered = []
+        for result in results:
+            # Estimate content difficulty (simplified)
+            difficulty = self._estimate_content_difficulty(result['title'] + " " + result['summary'])
+            
+            # Filter by level (allow content slightly above user level)
+            if difficulty <= user_level + 1:
+                result['estimated_difficulty'] = difficulty
+                filtered.append(result)
+        
+        return filtered
+    
+    def _estimate_content_difficulty(self, text):
+        """Estimate content difficulty (1-6 scale)"""
+        # Simple heuristics for difficulty estimation
+        word_count = len(text.split())
+        avg_word_length = sum(len(word) for word in text.split()) / word_count if word_count > 0 else 0
+        
+        # Technical terms increase difficulty
+        technical_terms = ['algorithm', 'implementation', 'architecture', 'methodology', 'paradigm']
+        tech_score = sum(1 for term in technical_terms if term in text.lower())
+        
+        # Calculate difficulty score
+        difficulty = 1
+        if avg_word_length > 6:
+            difficulty += 1
+        if tech_score > 0:
+            difficulty += 1
+        if word_count > 200:
+            difficulty += 1
+        
+        return min(difficulty, 6)
+    
+    def extract_content_from_url(self, url):
+        """Extract readable content from URL"""
+        try:
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+            }
+            
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.content, 'html.parser')
+            
+            # Remove unwanted elements
+            for element in soup(['script', 'style', 'nav', 'header', 'footer', 'aside']):
+                element.decompose()
+            
+            # Extract main content
+            main_content = soup.find('main') or soup.find('article') or soup.find('div', class_=re.compile(r'content|article|post'))
+            
+            if main_content:
+                text = main_content.get_text(separator=' ', strip=True)
+            else:
+                # Fallback to body text
+                text = soup.get_text(separator=' ', strip=True)
+            
+            # Clean up text
+            text = re.sub(r'\s+', ' ', text)  # Multiple spaces to single
+            text = text[:5000]  # Limit length
+            
+            return {
+                'success': True,
+                'content': text,
+                'title': soup.find('title').text if soup.find('title') else '',
+                'word_count': len(text.split())
+            }
+        
+        except Exception as e:
+            logger.error(f"Error extracting content from {url}: {e}")
+            return {
+                'success': False,
+                'error': str(e)
+            }
+    
+    def generate_personalized_recommendations(self, user_interests, recent_articles, english_level, context_focus, user_id=None):
+        """Generate AI-powered content recommendations"""
+        try:
+            if not groq_client and not genai_client:
+                return []
+            
+            # Prepare context for AI
+            interests_text = ', '.join(user_interests.keys())
+            recent_titles = [article.get('title', '') for article in recent_articles[-5:]]
+            recent_text = '; '.join(recent_titles)
+            
+            prompt = f"""
+            User Profile:
+            - English Level: {english_level}
+            - Context Focus: {context_focus}
+            - Interests: {interests_text}
+            - Recently read: {recent_text}
+            
+            Recommend 5 specific article topics or search terms that would be perfect for this user's English learning journey. 
+            Consider their level and interests. Focus on practical, engaging content.
+            
+            Format as JSON array: [
+                {{"topic": "topic name", "reason": "why this is good for the user", "difficulty": "estimated level"}},
+                ...
+            ]
+            """
+            
+            # Try Groq first, then Gemini
+            response_text = None
+            if groq_client:
+                response = groq_client.chat.completions.create(
+                    model="llama-3.1-8b-instant",
+                    messages=[{"role": "user", "content": prompt}],
+                    temperature=0.7
+                )
+                response_text = response.choices[0].message.content
+                
+                # Track token usage
+                if user_id and hasattr(response, 'usage'):
+                    self._track_token_usage(
+                        user_id, 'groq', 
+                        response.usage.prompt_tokens, 
+                        response.usage.completion_tokens, 
+                        'content_recommendations'
+                    )
+            elif genai_client:
+                model = genai_client.GenerativeModel('gemini-2.5-flash-latest')
+                response = model.generate_content(prompt)
+                response_text = response.text
+                
+                # Track token usage for Gemini (estimated)
+                if user_id:
+                    # Estimate tokens (rough approximation: 1 token ≈ 4 characters)
+                    input_tokens = len(prompt) // 4
+                    output_tokens = len(response_text) // 4
+                    self._track_token_usage(
+                        user_id, 'gemini', 
+                        input_tokens, 
+                        output_tokens, 
+                        'content_recommendations'
+                    )
+            
+            if response_text:
+                # Extract JSON from response
+                json_match = re.search(r'\[.*\]', response_text, re.DOTALL)
+                if json_match:
+                    recommendations = json.loads(json_match.group())
+                    return recommendations
+            
+            return []
+        
+        except Exception as e:
+            logger.error(f"Error generating recommendations: {e}")
+            return []
+    
+    def analyze_content_for_learning(self, content, user_level):
+        """Analyze content and suggest learning points"""
+        try:
+            if not groq_client and not genai_client:
+                return {}
+            
+            # Truncate content for analysis
+            analysis_content = content[:2000] + "..." if len(content) > 2000 else content
+            
+            prompt = f"""
+            Analyze this English text for a {user_level} level English learner:
+            
+            "{analysis_content}"
+            
+            Provide:
+            1. Key vocabulary words (5-8 words) with definitions
+            2. Important grammar patterns used
+            3. Main topics/themes
+            4. Difficulty assessment (1-10)
+            5. Learning suggestions for this level
+            
+            Format as JSON: {{
+                "vocabulary": [{{"word": "...", "definition": "..."}}, ...],
+                "grammar_patterns": ["pattern1", "pattern2", ...],
+                "topics": ["topic1", "topic2", ...],
+                "difficulty": 7,
+                "learning_suggestions": ["suggestion1", "suggestion2", ...]
+            }}
+            """
+            
+            response_text = None
+            if groq_client:
+                response = groq_client.chat.completions.create(
+                    model="llama-3.1-8b-instant",
+                    messages=[{"role": "user", "content": prompt}],
+                    temperature=0.3
+                )
+                response_text = response.choices[0].message.content
+            elif genai_client:
+                model = genai_client.GenerativeModel('gemini-2.5-flash-latest')
+                response = model.generate_content(prompt)
+                response_text = response.text
+            
+            if response_text:
+                json_match = re.search(r'\{.*\}', response_text, re.DOTALL)
+                if json_match:
+                    analysis = json.loads(json_match.group())
+                    return analysis
+            
+            return {}
+        
+        except Exception as e:
+            logger.error(f"Error analyzing content: {e}")
+            return {}
+
+# Global instance
+content_curator = ContentCurator()

database.py

@@ -0,0 +1,744 @@
+# database.py
+import sqlite3
+import os
+import hashlib
+import secrets
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from datetime import datetime, timedelta
+from functools import wraps
+from flask import g, session, jsonify, request
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Database configuration
+DATABASE_PATH = 'users.db'
+
+def get_db():
+    """Get database connection"""
+    if 'db' not in g:
+        g.db = sqlite3.connect(DATABASE_PATH)
+        g.db.row_factory = sqlite3.Row
+    return g.db
+
+def close_db(e=None):
+    """Close database connection"""
+    db = g.pop('db', None)
+    if db is not None:
+        db.close()
+
+def init_db():
+    """Initialize database with required tables"""
+    try:
+        db = sqlite3.connect(DATABASE_PATH)
+        db.executescript('''
+            -- Users table
+            CREATE TABLE IF NOT EXISTS users (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                email TEXT UNIQUE NOT NULL,
+                password_hash TEXT NOT NULL,
+                salt TEXT NOT NULL,
+                is_confirmed BOOLEAN DEFAULT FALSE,
+                confirmation_token TEXT,
+                reset_token TEXT,
+                reset_token_expires TIMESTAMP,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                last_login TIMESTAMP,
+                is_active BOOLEAN DEFAULT TRUE
+            );
+            
+            -- User flashcards table
+            CREATE TABLE IF NOT EXISTS user_flashcards (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id INTEGER NOT NULL,
+                term TEXT NOT NULL,
+                translation TEXT,
+                context_sentence TEXT,
+                gapped_sentence TEXT,
+                definition TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                study_count INTEGER DEFAULT 0,
+                last_studied TIMESTAMP,
+                difficulty_level INTEGER DEFAULT 1,
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+            );
+            
+            -- User study sessions table
+            CREATE TABLE IF NOT EXISTS study_sessions (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id INTEGER NOT NULL,
+                session_type TEXT NOT NULL, -- 'flashcard', 'conversation', 'activity'
+                duration_minutes INTEGER,
+                cards_studied INTEGER DEFAULT 0,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+            );
+            
+            -- User settings table
+            CREATE TABLE IF NOT EXISTS user_settings (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id INTEGER UNIQUE NOT NULL,
+                preferred_model TEXT DEFAULT 'gemini:gemini-2.5-flash-latest',
+                context_focus TEXT DEFAULT 'General/Social',
+                voice_accent TEXT DEFAULT 'co.uk',
+                daily_goal INTEGER DEFAULT 10,
+                notification_enabled BOOLEAN DEFAULT TRUE,
+                -- New settings for advanced features
+                english_level TEXT DEFAULT 'B1', -- A1, A2, B1, B2, C1, C2
+                study_goals TEXT, -- JSON: objectives like "business english", "technical vocabulary"
+                preferred_content_types TEXT DEFAULT 'articles,videos', -- comma separated
+                content_difficulty TEXT DEFAULT 'adaptive', -- 'easy', 'medium', 'hard', 'adaptive'
+                study_schedule TEXT, -- JSON: preferred days/times
+                auto_recommendations BOOLEAN DEFAULT TRUE,
+                content_sources TEXT DEFAULT 'news,tech,business', -- preferred content sources
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+            );
+            
+            -- User articles/content table
+            CREATE TABLE IF NOT EXISTS user_articles (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id INTEGER NOT NULL,
+                title TEXT NOT NULL,
+                content TEXT NOT NULL,
+                source_url TEXT,
+                source_type TEXT DEFAULT 'manual', -- 'manual', 'web_search', 'recommended'
+                category TEXT, -- user interest category
+                difficulty_level TEXT, -- estimated difficulty
+                word_count INTEGER,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                last_accessed TIMESTAMP,
+                is_favorite BOOLEAN DEFAULT FALSE,
+                study_progress REAL DEFAULT 0.0, -- 0.0 to 1.0
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+            );
+            
+            -- User interests/preferences table
+            CREATE TABLE IF NOT EXISTS user_interests (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id INTEGER NOT NULL,
+                interest_category TEXT NOT NULL,
+                weight REAL DEFAULT 1.0, -- importance weight
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE,
+                UNIQUE(user_id, interest_category)
+            );
+            
+            -- Content recommendations table
+            CREATE TABLE IF NOT EXISTS content_recommendations (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id INTEGER NOT NULL,
+                article_id INTEGER,
+                recommendation_reason TEXT,
+                relevance_score REAL,
+                recommended_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                viewed BOOLEAN DEFAULT FALSE,
+                accepted BOOLEAN DEFAULT FALSE,
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE,
+                FOREIGN KEY (article_id) REFERENCES user_articles (id) ON DELETE CASCADE
+            );
+            
+            -- Study plans table
+            CREATE TABLE IF NOT EXISTS study_plans (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id INTEGER NOT NULL,
+                plan_name TEXT NOT NULL,
+                target_level TEXT, -- A1, A2, B1, B2, C1, C2
+                current_level TEXT,
+                objectives TEXT, -- JSON string with objectives
+                weekly_hours INTEGER DEFAULT 5,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                is_active BOOLEAN DEFAULT TRUE,
+                completion_percentage REAL DEFAULT 0.0,
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+            );
+            
+            -- Study plan activities table
+            CREATE TABLE IF NOT EXISTS study_plan_activities (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                plan_id INTEGER NOT NULL,
+                activity_type TEXT NOT NULL, -- 'reading', 'flashcards', 'conversation', 'writing'
+                content_reference TEXT, -- reference to article, flashcard set, etc.
+                scheduled_date DATE,
+                estimated_duration INTEGER, -- minutes
+                actual_duration INTEGER,
+                completed BOOLEAN DEFAULT FALSE,
+                completed_at TIMESTAMP,
+                difficulty_rating INTEGER, -- 1-5 user rating
+                notes TEXT,
+                FOREIGN KEY (plan_id) REFERENCES study_plans (id) ON DELETE CASCADE
+            );
+            
+            -- User analytics table
+            CREATE TABLE IF NOT EXISTS user_analytics (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id INTEGER NOT NULL,
+                metric_name TEXT NOT NULL,
+                metric_value REAL NOT NULL,
+                metric_date DATE NOT NULL,
+                context_data TEXT, -- JSON with additional context
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+            );
+            
+            -- Token usage tracking table for admin
+            CREATE TABLE IF NOT EXISTS token_usage (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                user_id INTEGER,
+                api_provider TEXT NOT NULL, -- 'groq', 'gemini', etc.
+                input_tokens INTEGER DEFAULT 0,
+                output_tokens INTEGER DEFAULT 0,
+                operation_type TEXT, -- 'conversation', 'content_analysis', 'recommendation', etc.
+                tokens_used INTEGER GENERATED ALWAYS AS (input_tokens + output_tokens) STORED,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
+            );
+            
+            -- Create indexes for better performance
+            CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
+            CREATE INDEX IF NOT EXISTS idx_users_confirmation_token ON users(confirmation_token);
+            CREATE INDEX IF NOT EXISTS idx_users_reset_token ON users(reset_token);
+            CREATE INDEX IF NOT EXISTS idx_flashcards_user_id ON user_flashcards(user_id);
+            CREATE INDEX IF NOT EXISTS idx_sessions_user_id ON study_sessions(user_id);
+            CREATE INDEX IF NOT EXISTS idx_settings_user_id ON user_settings(user_id);
+            CREATE INDEX IF NOT EXISTS idx_articles_user_id ON user_articles(user_id);
+            CREATE INDEX IF NOT EXISTS idx_articles_category ON user_articles(category);
+            CREATE INDEX IF NOT EXISTS idx_interests_user_id ON user_interests(user_id);
+            CREATE INDEX IF NOT EXISTS idx_recommendations_user_id ON content_recommendations(user_id);
+            CREATE INDEX IF NOT EXISTS idx_study_plans_user_id ON study_plans(user_id);
+            CREATE INDEX IF NOT EXISTS idx_plan_activities_plan_id ON study_plan_activities(plan_id);
+            CREATE INDEX IF NOT EXISTS idx_analytics_user_date ON user_analytics(user_id, metric_date);
+            CREATE INDEX IF NOT EXISTS idx_token_usage_user_id ON token_usage(user_id);
+            CREATE INDEX IF NOT EXISTS idx_token_usage_provider ON token_usage(api_provider);
+            CREATE INDEX IF NOT EXISTS idx_token_usage_date ON token_usage(created_at);
+        ''')
+        db.commit()
+        db.close()
+        logger.info("Database initialized successfully")
+        return True
+    except Exception as e:
+        logger.error(f"Error initializing database: {e}")
+        return False
+
+def hash_password(password, salt=None):
+    """Hash password with salt"""
+    if salt is None:
+        salt = secrets.token_hex(32)
+    
+    password_hash = hashlib.pbkdf2_hmac(
+        'sha256',
+        password.encode('utf-8'),
+        salt.encode('utf-8'),
+        100000  # iterations
+    )
+    return password_hash.hex(), salt
+
+def verify_password(password, password_hash, salt):
+    """Verify password against hash"""
+    new_hash, _ = hash_password(password, salt)
+    return new_hash == password_hash
+
+def generate_token():
+    """Generate secure random token"""
+    return secrets.token_urlsafe(32)
+
+def create_user(email, password):
+    """Create new user account"""
+    try:
+        db = get_db()
+        
+        # Check if user already exists
+        existing_user = db.execute(
+            'SELECT id FROM users WHERE email = ?', (email,)
+        ).fetchone()
+        
+        if existing_user:
+            return {'success': False, 'message': 'Email already registered'}
+        
+        # Hash password
+        password_hash, salt = hash_password(password)
+        confirmation_token = generate_token()
+        
+        # Insert user
+        cursor = db.execute(
+            '''INSERT INTO users (email, password_hash, salt, confirmation_token) 
+               VALUES (?, ?, ?, ?)''',
+            (email, password_hash, salt, confirmation_token)
+        )
+        user_id = cursor.lastrowid
+        
+        # Create default user settings
+        db.execute(
+            '''INSERT INTO user_settings (user_id) VALUES (?)''',
+            (user_id,)
+        )
+        
+        db.commit()
+        
+        logger.info(f"User created: {email}")
+        return {
+            'success': True, 
+            'user_id': user_id,
+            'confirmation_token': confirmation_token,
+            'message': 'User created successfully'
+        }
+        
+    except Exception as e:
+        logger.error(f"Error creating user: {e}")
+        return {'success': False, 'message': 'Internal server error'}
+
+def authenticate_user(email, password):
+    """Authenticate user login"""
+    try:
+        db = get_db()
+        user = db.execute(
+            '''SELECT id, email, password_hash, salt, is_confirmed, is_active 
+               FROM users WHERE email = ?''', (email,)
+        ).fetchone()
+        
+        if not user:
+            return {'success': False, 'message': 'Invalid email or password'}
+        
+        if not user['is_active']:
+            return {'success': False, 'message': 'Account is deactivated'}
+        
+        if not verify_password(password, user['password_hash'], user['salt']):
+            return {'success': False, 'message': 'Invalid email or password'}
+        
+        if not user['is_confirmed']:
+            return {'success': False, 'message': 'Please confirm your email before logging in'}
+        
+        # Update last login
+        db.execute(
+            'UPDATE users SET last_login = CURRENT_TIMESTAMP WHERE id = ?',
+            (user['id'],)
+        )
+        db.commit()
+        
+        return {
+            'success': True,
+            'user_id': user['id'],
+            'email': user['email'],
+            'message': 'Login successful'
+        }
+        
+    except Exception as e:
+        logger.error(f"Error authenticating user: {e}")
+        return {'success': False, 'message': 'Internal server error'}
+
+def confirm_email(token):
+    """Confirm user email with token"""
+    try:
+        db = get_db()
+        user = db.execute(
+            'SELECT id, email FROM users WHERE confirmation_token = ? AND is_confirmed = FALSE',
+            (token,)
+        ).fetchone()
+        
+        if not user:
+            return {'success': False, 'message': 'Invalid or expired confirmation token'}
+        
+        db.execute(
+            '''UPDATE users SET is_confirmed = TRUE, confirmation_token = NULL 
+               WHERE id = ?''',
+            (user['id'],)
+        )
+        db.commit()
+        
+        logger.info(f"Email confirmed for user: {user['email']}")
+        return {'success': True, 'message': 'Email confirmed successfully'}
+        
+    except Exception as e:
+        logger.error(f"Error confirming email: {e}")
+        return {'success': False, 'message': 'Internal server error'}
+
+def get_user_settings(user_id):
+    """Get user settings"""
+    try:
+        db = get_db()
+        settings = db.execute(
+            '''SELECT preferred_model, context_focus, voice_accent, daily_goal, notification_enabled
+               FROM user_settings WHERE user_id = ?''',
+            (user_id,)
+        ).fetchone()
+        
+        if settings:
+            return dict(settings)
+        return None
+        
+    except Exception as e:
+        logger.error(f"Error getting user settings: {e}")
+        return None
+
+def update_user_settings(user_id, settings):
+    """Update user settings"""
+    try:
+        db = get_db()
+        db.execute(
+            '''UPDATE user_settings 
+               SET preferred_model = ?, context_focus = ?, voice_accent = ?, 
+                   daily_goal = ?, notification_enabled = ?
+               WHERE user_id = ?''',
+            (settings.get('preferred_model'), settings.get('context_focus'),
+             settings.get('voice_accent'), settings.get('daily_goal'),
+             settings.get('notification_enabled'), user_id)
+        )
+        db.commit()
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error updating user settings: {e}")
+        return False
+
+def save_user_flashcard(user_id, flashcard_data):
+    """Save flashcard to user's collection"""
+    try:
+        db = get_db()
+        db.execute(
+            '''INSERT INTO user_flashcards 
+               (user_id, term, translation, context_sentence, gapped_sentence, definition)
+               VALUES (?, ?, ?, ?, ?, ?)''',
+            (user_id, flashcard_data.get('term'), flashcard_data.get('translation'),
+             flashcard_data.get('context_sentence'), flashcard_data.get('gapped_sentence'),
+             flashcard_data.get('definition'))
+        )
+        db.commit()
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error saving flashcard: {e}")
+        return False
+
+def get_user_flashcards(user_id, limit=50):
+    """Get user's flashcards"""
+    try:
+        db = get_db()
+        flashcards = db.execute(
+            '''SELECT * FROM user_flashcards 
+               WHERE user_id = ? 
+               ORDER BY created_at DESC 
+               LIMIT ?''',
+            (user_id, limit)
+        ).fetchall()
+        
+        return [dict(card) for card in flashcards]
+        
+    except Exception as e:
+        logger.error(f"Error getting user flashcards: {e}")
+        return []
+
+def record_study_session(user_id, session_type, duration_minutes=None, cards_studied=0):
+    """Record a study session"""
+    try:
+        db = get_db()
+        db.execute(
+            '''INSERT INTO study_sessions (user_id, session_type, duration_minutes, cards_studied)
+               VALUES (?, ?, ?, ?)''',
+            (user_id, session_type, duration_minutes, cards_studied)
+        )
+        db.commit()
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error recording study session: {e}")
+        return False
+
+# Authentication decorators
+def login_required(f):
+    """Decorator to require login"""
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if 'user_id' not in session:
+            return jsonify({'error': 'Authentication required'}), 401
+        return f(*args, **kwargs)
+    return decorated_function
+
+def get_current_user():
+    """Get current logged in user"""
+    if 'user_id' in session:
+        try:
+            db = get_db()
+            user = db.execute(
+                'SELECT id, email, is_confirmed FROM users WHERE id = ? AND is_active = TRUE',
+                (session['user_id'],)
+            ).fetchone()
+            return dict(user) if user else None
+        except Exception as e:
+            logger.error(f"Error getting current user: {e}")
+            return None
+    return None
+
+# Email functionality (for Hugging Face Spaces)
+def send_confirmation_email(email, token):
+    """Send confirmation email (simplified for HF Spaces)"""
+    try:
+        # For Hugging Face Spaces, we'll use environment variables for SMTP
+        smtp_server = os.environ.get('SMTP_SERVER', 'smtp.gmail.com')
+        smtp_port = int(os.environ.get('SMTP_PORT', '587'))
+        smtp_username = os.environ.get('SMTP_USERNAME')
+        smtp_password = os.environ.get('SMTP_PASSWORD')
+        
+        if not all([smtp_username, smtp_password]):
+            logger.warning("SMTP credentials not configured")
+            return False
+        
+        # Create confirmation URL (will be updated with actual domain)
+        base_url = os.environ.get('BASE_URL', 'http://localhost:7860')
+        confirm_url = f"{base_url}/confirm-email?token={token}"
+        
+        # Create email
+        msg = MIMEMultipart()
+        msg['From'] = smtp_username
+        msg['To'] = email
+        msg['Subject'] = "Confirm your English Helper account"
+        
+        body = f"""
+        <html>
+        <body>
+            <h2>Welcome to Dynamic English Study Studio!</h2>
+            <p>Thank you for creating an account. Please click the link below to confirm your email address:</p>
+            <p><a href="{confirm_url}" style="background-color: #4f46e5; color: white; padding: 10px 20px; text-decoration: none; border-radius: 5px;">Confirm Email</a></p>
+            <p>If the button doesn't work, copy and paste this link into your browser:</p>
+            <p>{confirm_url}</p>
+            <p>This link will expire in 24 hours.</p>
+            <p>If you didn't create this account, please ignore this email.</p>
+        </body>
+        </html>
+        """
+        
+        msg.attach(MIMEText(body, 'html'))
+        
+        # Send email
+        server = smtplib.SMTP(smtp_server, smtp_port)
+        server.starttls()
+        server.login(smtp_username, smtp_password)
+        text = msg.as_string()
+        server.sendmail(smtp_username, email, text)
+        server.quit()
+        
+        logger.info(f"Confirmation email sent to {email}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error sending confirmation email: {e}")
+        return False
+
+# --- CONTENT CURATION FUNCTIONS ---
+
+def save_user_article(user_id, title, content, source_url=None, source_type='manual', category=None):
+    """Save article/content for user"""
+    try:
+        db = get_db()
+        word_count = len(content.split()) if content else 0
+        
+        cursor = db.execute(
+            '''INSERT INTO user_articles 
+               (user_id, title, content, source_url, source_type, category, word_count)
+               VALUES (?, ?, ?, ?, ?, ?, ?)''',
+            (user_id, title, content, source_url, source_type, category, word_count)
+        )
+        article_id = cursor.lastrowid
+        db.commit()
+        
+        logger.info(f"Article saved for user {user_id}: {title}")
+        return {'success': True, 'article_id': article_id}
+        
+    except Exception as e:
+        logger.error(f"Error saving article: {e}")
+        return {'success': False, 'message': 'Failed to save article'}
+
+def get_user_articles(user_id, category=None, limit=50):
+    """Get user's saved articles"""
+    try:
+        db = get_db()
+        
+        if category:
+            articles = db.execute(
+                '''SELECT * FROM user_articles 
+                   WHERE user_id = ? AND category = ?
+                   ORDER BY created_at DESC LIMIT ?''',
+                (user_id, category, limit)
+            ).fetchall()
+        else:
+            articles = db.execute(
+                '''SELECT * FROM user_articles 
+                   WHERE user_id = ? 
+                   ORDER BY created_at DESC LIMIT ?''',
+                (user_id, limit)
+            ).fetchall()
+        
+        return [dict(article) for article in articles]
+        
+    except Exception as e:
+        logger.error(f"Error getting user articles: {e}")
+        return []
+
+def update_user_interests(user_id, interests):
+    """Update user's interests/categories"""
+    try:
+        db = get_db()
+        
+        # Clear existing interests
+        db.execute('DELETE FROM user_interests WHERE user_id = ?', (user_id,))
+        
+        # Add new interests
+        for interest, weight in interests.items():
+            db.execute(
+                '''INSERT INTO user_interests (user_id, interest_category, weight)
+                   VALUES (?, ?, ?)''',
+                (user_id, interest, weight)
+            )
+        
+        db.commit()
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error updating user interests: {e}")
+        return False
+
+def get_user_interests(user_id):
+    """Get user's interests"""
+    try:
+        db = get_db()
+        interests = db.execute(
+            'SELECT interest_category, weight FROM user_interests WHERE user_id = ?',
+            (user_id,)
+        ).fetchall()
+        
+        return {interest['interest_category']: interest['weight'] for interest in interests}
+        
+    except Exception as e:
+        logger.error(f"Error getting user interests: {e}")
+        return {}
+
+def create_study_plan(user_id, plan_name, target_level, current_level, objectives, weekly_hours=5):
+    """Create new study plan"""
+    try:
+        db = get_db()
+        
+        cursor = db.execute(
+            '''INSERT INTO study_plans 
+               (user_id, plan_name, target_level, current_level, objectives, weekly_hours)
+               VALUES (?, ?, ?, ?, ?, ?)''',
+            (user_id, plan_name, target_level, current_level, objectives, weekly_hours)
+        )
+        plan_id = cursor.lastrowid
+        db.commit()
+        
+        logger.info(f"Study plan created for user {user_id}: {plan_name}")
+        return {'success': True, 'plan_id': plan_id}
+        
+    except Exception as e:
+        logger.error(f"Error creating study plan: {e}")
+        return {'success': False, 'message': 'Failed to create study plan'}
+
+def get_user_study_plans(user_id):
+    """Get user's study plans"""
+    try:
+        db = get_db()
+        plans = db.execute(
+            '''SELECT * FROM study_plans 
+               WHERE user_id = ? 
+               ORDER BY created_at DESC''',
+            (user_id,)
+        ).fetchall()
+        
+        return [dict(plan) for plan in plans]
+        
+    except Exception as e:
+        logger.error(f"Error getting study plans: {e}")
+        return []
+
+def add_study_activity(plan_id, activity_type, content_reference, scheduled_date, estimated_duration):
+    """Add activity to study plan"""
+    try:
+        db = get_db()
+        
+        db.execute(
+            '''INSERT INTO study_plan_activities 
+               (plan_id, activity_type, content_reference, scheduled_date, estimated_duration)
+               VALUES (?, ?, ?, ?, ?)''',
+            (plan_id, activity_type, content_reference, scheduled_date, estimated_duration)
+        )
+        db.commit()
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error adding study activity: {e}")
+        return False
+
+def get_study_activities(plan_id, date_range=None):
+    """Get activities for study plan"""
+    try:
+        db = get_db()
+        
+        if date_range:
+            start_date, end_date = date_range
+            activities = db.execute(
+                '''SELECT * FROM study_plan_activities 
+                   WHERE plan_id = ? AND scheduled_date BETWEEN ? AND ?
+                   ORDER BY scheduled_date''',
+                (plan_id, start_date, end_date)
+            ).fetchall()
+        else:
+            activities = db.execute(
+                '''SELECT * FROM study_plan_activities 
+                   WHERE plan_id = ? 
+                   ORDER BY scheduled_date''',
+                (plan_id,)
+            ).fetchall()
+        
+        return [dict(activity) for activity in activities]
+        
+    except Exception as e:
+        logger.error(f"Error getting study activities: {e}")
+        return []
+
+def record_analytics_metric(user_id, metric_name, metric_value, context_data=None):
+    """Record analytics metric"""
+    try:
+        db = get_db()
+        
+        db.execute(
+            '''INSERT INTO user_analytics (user_id, metric_name, metric_value, metric_date, context_data)
+               VALUES (?, ?, ?, DATE('now'), ?)''',
+            (user_id, metric_name, metric_value, context_data)
+        )
+        db.commit()
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error recording analytics: {e}")
+        return False
+
+def get_user_analytics(user_id, metric_name=None, days=30):
+    """Get user analytics data"""
+    try:
+        db = get_db()
+        
+        if metric_name:
+            analytics = db.execute(
+                '''SELECT * FROM user_analytics 
+                   WHERE user_id = ? AND metric_name = ? 
+                   AND metric_date >= DATE('now', '-{} days')
+                   ORDER BY metric_date DESC'''.format(days),
+                (user_id, metric_name)
+            ).fetchall()
+        else:
+            analytics = db.execute(
+                '''SELECT * FROM user_analytics 
+                   WHERE user_id = ? 
+                   AND metric_date >= DATE('now', '-{} days')
+                   ORDER BY metric_date DESC'''.format(days),
+                (user_id,)
+            ).fetchall()
+        
+        return [dict(metric) for metric in analytics]
+        
+    except Exception as e:
+        logger.error(f"Error getting analytics: {e}")
+        return []

index.html

@@ -0,0 +1,1959 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Dynamic English Study Studio</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+        body { font-family: 'Inter', sans-serif; background-color: #f7f9fc; }
+        .card { background-color: white; border-radius: 12px; box-shadow: 0 4px_12px rgba(0,0,0,0.08); padding: 24px; }
+        .btn { padding: 0.5rem 1rem; border-radius: 8px; font-weight: 600; transition: all 0.2s; display: inline-flex; align-items: center; justify-content: center; cursor: pointer; }
+        .btn:disabled { cursor: not-allowed; opacity: 0.5; }
+        .btn-primary { background-color: #4f46e5; color: white; }
+        .btn-primary:hover:not(:disabled) { background-color: #4338ca; }
+        .spinner { border: 2px solid rgba(255,255,255,0.3); width: 20px; height: 20px; border-radius: 50%; border-left-color: #fff; animation: spin 1s ease infinite; }
+        @keyframes spin { to { transform: rotate(360deg); } }
+        .flashcard-container { perspective: 1000px; position: relative; }
+        .flashcard-inner { position: relative; width: 100%; transition: transform 0.6s; transform-style: preserve-3d; }
+        .flashcard-container.flipped .flashcard-inner { transform: rotateY(180deg); }
+        .flashcard-front, .flashcard-back { position: absolute; width: 100%; height:100%; backface-visibility: hidden; border: 1px solid #e5e7eb; border-radius: 12px; padding: 20px; display: flex; flex-direction: column; justify-content: space-between; }
+        .flashcard-front { background-color: #f9fafb; }
+        .flashcard-back { background-color: #ffffff; transform: rotateY(180deg); }
+        .audio-btn { background: none; border: none; font-size: 1.5rem; cursor: pointer; color: #4f46e5; padding: 0; }
+        .delete-btn { position: absolute; top: 10px; right: 10px; background: none; border: none; font-size: 1.2rem; cursor: pointer; color: #9ca3af; z-index: 10; }
+        .delete-btn:hover { color: #ef4444; }
+        #activityChatDisplay { border: 1px solid #e5e7eb; border-radius: 8px; padding: 1rem; min-height: 150px; background-color: #f9fafb; }
+        .ai-prompt { border-bottom: 2px dashed #d1d5db; padding-bottom: 1rem; margin-bottom: 1rem; }
+        .user-response-display { background-color: #eef2ff; border-left: 4px solid #4f46e5; padding: 0.75rem; margin-bottom: 1rem; font-style: italic; }
+        .ai-feedback { background-color: #f0fdf4; border-left: 4px solid #22c55e; padding: 0.75rem; }
+        .ai-feedback h3 { font-weight: 700; }
+        
+        /* Toast Notifications */
+        .toast-container { position: fixed; top: 20px; right: 20px; z-index: 1000; max-width: 400px; }
+        .toast { background: white; border-left: 4px solid #4f46e5; border-radius: 8px; box-shadow: 0 10px 25px rgba(0,0,0,0.15); padding: 1rem; margin-bottom: 0.5rem; opacity: 0; transform: translateX(100%); transition: all 0.3s ease; }
+        .toast.show { opacity: 1; transform: translateX(0); }
+        .toast.error { border-left-color: #ef4444; }
+        .toast.success { border-left-color: #10b981; }
+        .toast.warning { border-left-color: #f59e0b; }
+        .toast-close { float: right; background: none; border: none; font-size: 1.2rem; cursor: pointer; color: #9ca3af; }
+        
+        /* Loading States & Skeleton */
+        .loading-skeleton { 
+            background: linear-gradient(90deg, #f0f0f0 25%, #e0e0e0 50%, #f0f0f0 75%); 
+            background-size: 200% 100%; 
+            animation: loading 1.5s infinite; 
+            border-radius: 4px;
+        }
+        @keyframes loading { 0% { background-position: 200% 0; } 100% { background-position: -200% 0; } }
+        
+        .skeleton-text { height: 1rem; margin: 0.25rem 0; }
+        .skeleton-text.large { height: 1.5rem; }
+        .skeleton-text.small { height: 0.75rem; }
+        .skeleton-box { height: 100px; border-radius: 8px; }
+        
+        /* Enhanced Loading Spinner */
+        .spinner-container { display: flex; align-items: center; justify-content: center; padding: 2rem; }
+        .spinner-large { width: 40px; height: 40px; border-width: 4px; }
+        
+        /* Fade in animations */
+        .fade-in { animation: fadeIn 0.5s ease-in; }
+        @keyframes fadeIn { from { opacity: 0; transform: translateY(10px); } to { opacity: 1; transform: translateY(0); } }
+        
+        /* Slide in animations */
+        .slide-in { animation: slideIn 0.3s ease-out; }
+        @keyframes slideIn { from { transform: translateX(-20px); opacity: 0; } to { transform: translateX(0); opacity: 1; } }
+        
+        /* Empty states */
+        .empty-state { 
+            text-align: center; padding: 3rem 1rem; color: #6b7280; 
+            background: #f9fafb; border: 2px dashed #d1d5db; border-radius: 12px; margin: 1rem 0;
+        }
+        .empty-state-icon { font-size: 3rem; margin-bottom: 1rem; opacity: 0.5; }
+        .empty-state-title { font-size: 1.25rem; font-weight: 600; margin-bottom: 0.5rem; color: #374151; }
+        .empty-state-description { font-size: 0.875rem; line-height: 1.5; }
+        
+        /* Enhanced Flashcards - Responsive */
+        .flashcard-container { perspective: 1000px; position: relative; }
+        .flashcard-inner { position: relative; width: 100%; min-height: 280px; transition: transform 0.6s; transform-style: preserve-3d; }
+        .flashcard-container.flipped .flashcard-inner { transform: rotateY(180deg); }
+        .flashcard-front, .flashcard-back { 
+            position: absolute; width: 100%; height: 100%; min-height: 280px; backface-visibility: hidden; 
+            border: 1px solid #e5e7eb; border-radius: 12px; padding: 20px; display: flex; flex-direction: column; 
+            justify-content: space-between; word-wrap: break-word; overflow-wrap: break-word; 
+        }
+        .flashcard-front { background-color: #f9fafb; }
+        .flashcard-back { background-color: #ffffff; transform: rotateY(180deg); }
+        
+        /* Responsive text handling */
+        .flashcard-text { 
+            font-size: 1rem; line-height: 1.5; max-height: 150px; overflow-y: auto; 
+            word-break: break-word; hyphens: auto; padding: 0.25rem 0;
+        }
+        
+        /* Mobile responsiveness */
+        @media (max-width: 768px) {
+            .flashcard-text { font-size: 0.9rem; max-height: 120px; line-height: 1.4; }
+            .flashcard-container { margin-bottom: 1rem; }
+            .flashcard-inner { min-height: 250px; }
+            .flashcard-front, .flashcard-back { min-height: 250px; padding: 16px; }
+            .card { padding: 16px; }
+            body { padding: 0.5rem; }
+            .container { padding: 0; }
+            
+            /* Adjust grid for mobile */
+            .grid.grid-cols-1.md\\:grid-cols-3 { grid-template-columns: 1fr; }
+            .grid.grid-cols-1.lg\\:grid-cols-2 { grid-template-columns: 1fr; }
+        }
+        
+        @media (max-width: 480px) {
+            .flashcard-text { font-size: 0.85rem; max-height: 100px; }
+            .flashcard-inner { min-height: 220px; }
+            .flashcard-front, .flashcard-back { min-height: 220px; padding: 12px; }
+            
+            /* Make buttons more touch-friendly */
+            .btn { padding: 0.75rem 1rem; min-height: 44px; }
+            .audio-btn { font-size: 1.25rem; padding: 0.5rem; }
+            .delete-btn { font-size: 1rem; padding: 0.5rem; }
+        }
+        
+        /* Text overflow handling */
+        .text-truncate { 
+            overflow: hidden; 
+            text-overflow: ellipsis; 
+            white-space: nowrap; 
+        }
+        
+        .text-wrap { 
+            white-space: normal; 
+            word-wrap: break-word; 
+            overflow-wrap: break-word; 
+        }
+        
+        /* Form Validation */
+        .form-error { border-color: #ef4444 !important; }
+        .error-message { color: #ef4444; font-size: 0.875rem; margin-top: 0.25rem; }
+        
+        /* Enhanced buttons */
+        .btn { position: relative; overflow: hidden; }
+        .btn::after { content: ''; position: absolute; top: 50%; left: 50%; width: 0; height: 0; border-radius: 50%; background: rgba(255,255,255,0.3); transform: translate(-50%, -50%); transition: width 0.3s, height 0.3s; }
+        .btn:active::after { width: 300px; height: 300px; }
+        
+        /* Pulse animation for mic button */
+        .mic-button.is-recording { animation: pulse 1.5s infinite; }
+        @keyframes pulse { 0%, 100% { transform: scale(1); } 50% { transform: scale(1.1); } }
+        
+        /* Auth Modal */
+        .modal { display: none; position: fixed; z-index: 1000; left: 0; top: 0; width: 100%; height: 100%; background-color: rgba(0,0,0,0.5); }
+        .modal.show { display: block; }
+        .modal-content { 
+            background-color: white; margin: 5% auto; padding: 0; width: 90%; max-width: 400px; 
+            border-radius: 12px; position: relative; animation: modalSlideIn 0.3s ease;
+        }
+        @keyframes modalSlideIn { from { opacity: 0; transform: translateY(-50px); } to { opacity: 1; transform: translateY(0); } }
+        .modal-header { padding: 1.5rem; border-bottom: 1px solid #e5e7eb; }
+        .modal-body { padding: 1.5rem; }
+        .modal-footer { padding: 1rem 1.5rem; border-top: 1px solid #e5e7eb; display: flex; justify-content: flex-end; gap: 0.5rem; }
+        .close { color: #aaa; float: right; font-size: 28px; font-weight: bold; cursor: pointer; }
+        .close:hover { color: #000; }
+        
+        /* Auth Form */
+        .auth-form { display: none; }
+        .auth-form.active { display: block; }
+        .form-group { margin-bottom: 1rem; }
+        .form-group label { display: block; margin-bottom: 0.25rem; font-weight: 500; color: #374151; }
+        .form-group input { width: 100%; padding: 0.75rem; border: 1px solid #d1d5db; border-radius: 6px; font-size: 0.875rem; }
+        .form-group input:focus { outline: none; border-color: #4f46e5; box-shadow: 0 0 0 3px rgba(79, 70, 229, 0.1); }
+        
+        /* User Menu */
+        .user-menu { position: relative; display: inline-block; }
+        .user-menu-content { display: none; position: absolute; right: 0; background-color: white; min-width: 200px; box-shadow: 0 8px 16px rgba(0,0,0,0.1); border-radius: 8px; z-index: 1; border: 1px solid #e5e7eb; }
+        .user-menu.show .user-menu-content { display: block; }
+        .user-menu-item { padding: 0.75rem 1rem; display: block; color: #374151; text-decoration: none; border-bottom: 1px solid #f3f4f6; }
+        .user-menu-item:hover { background-color: #f9fafb; }
+        .user-menu-item:last-child { border-bottom: none; }
+        
+        /* Header Auth Section */
+        .auth-section { display: flex; align-items: center; gap: 0.5rem; }
+        .user-avatar { width: 40px; height: 40px; border-radius: 50%; background-color: #4f46e5; color: white; display: flex; align-items: center; justify-content: center; font-weight: 600; cursor: pointer; }
+        
+        /* Content Curation Styles */
+        .content-item { 
+            border: 1px solid #e5e7eb; border-radius: 8px; padding: 1rem; margin-bottom: 1rem;
+            background: white; transition: all 0.2s;
+        }
+        .content-item:hover { box-shadow: 0 4px 12px rgba(0,0,0,0.1); border-color: #4f46e5; }
+        .content-item-title { font-weight: 600; color: #1f2937; margin-bottom: 0.5rem; }
+        .content-item-meta { font-size: 0.75rem; color: #6b7280; margin-bottom: 0.5rem; }
+        .content-item-summary { font-size: 0.875rem; color: #4b5563; line-height: 1.5; }
+        .difficulty-badge { 
+            display: inline-block; padding: 0.25rem 0.5rem; border-radius: 4px; font-size: 0.75rem; font-weight: 500;
+        }
+        .difficulty-easy { background-color: #dcfce7; color: #166534; }
+        .difficulty-medium { background-color: #fef3c7; color: #92400e; }
+        .difficulty-hard { background-color: #fee2e2; color: #991b1b; }
+        
+        /* Analytics Styles */
+        .metric-card { 
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); 
+            color: white; border-radius: 12px; padding: 1.5rem; text-align: center; 
+        }
+        .metric-value { font-size: 2rem; font-weight: bold; margin-bottom: 0.5rem; }
+        .metric-label { font-size: 0.875rem; opacity: 0.9; }
+        
+        /* Study Plan Styles */
+        .plan-activity { 
+            display: flex; align-items: center; padding: 0.75rem; border-radius: 6px; 
+            border-left: 4px solid #4f46e5; background-color: #f8fafc; margin-bottom: 0.5rem;
+        }
+        .plan-activity-icon { margin-right: 0.75rem; font-size: 1.25rem; }
+        .plan-activity-text { flex-grow: 1; font-size: 0.875rem; }
+        .plan-activity-time { font-size: 0.75rem; color: #6b7280; }
+    </style>
+</head>
+<body class="p-4 md:p-8">
+    <!-- Toast Container -->
+    <div id="toastContainer" class="toast-container"></div>
+
+    <div class="container mx-auto max-w-5xl">
+        <header class="mb-10">
+            <div class="flex justify-between items-center mb-6">
+                <div>
+                    <h1 class="text-3xl lg:text-4xl font-bold text-gray-800">Dynamic English Study Studio</h1>
+                    <p class="text-gray-500 mt-2">Your study tool with audio, images, and conversation & pronunciation practice.</p>
+                </div>
+                <div class="auth-section">
+                    <!-- Guest state -->
+                    <div id="guestAuth" class="flex gap-2">
+                        <button onclick="showAuthModal('login')" class="btn btn-primary">Login</button>
+                        <button onclick="showAuthModal('register')" class="btn bg-gray-500 hover:bg-gray-600 text-white">Sign Up</button>
+                    </div>
+                    
+                    <!-- Authenticated state -->
+                    <div id="userAuth" class="user-menu" style="display: none;">
+                        <div class="user-avatar" onclick="toggleUserMenu()" id="userAvatar">U</div>
+                        <div class="user-menu-content">
+                            <div class="user-menu-item" style="font-weight: 600; color: #4f46e5;" id="userEmail">user@example.com</div>
+                            <a href="#" onclick="showUserSettings()" class="user-menu-item">⚙️ Settings</a>
+                            <a href="#" onclick="showUserFlashcards()" class="user-menu-item">📚 My Flashcards</a>
+                            <a href="#" onclick="logout()" class="user-menu-item">🚪 Logout</a>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </header>
+
+        <div class="card mb-8">
+            <h2 class="text-xl font-semibold mb-4 text-gray-700">Global Session Settings</h2>
+            <div class="grid grid-cols-1 md:grid-cols-3 gap-4">
+                <div>
+                   <label for="modelSelector" class="block text-sm font-medium text-gray-700">Main AI Model</label>
+                   <select id="modelSelector" class="mt-1 block w-full pl-3 pr-10 py-2 text-base border-gray-300 rounded-md shadow-sm">
+                       <option>Loading models...</option>
+                   </select>
+                </div>
+               <div>
+                   <label for="contextSelector" class="block text-sm font-medium text-gray-700">Vocabulary Focus</label>
+                   <select id="contextSelector" class="mt-1 block w-full pl-3 pr-10 py-2 text-base border-gray-300 rounded-md shadow-sm">
+                       <option value="General/Social">General/Social</option>
+                       <option value="Professional/Business">Professional/Business</option>
+                       <option value="Technical/IT">Technical/IT</option>
+                   </select>
+               </div>
+               <div>
+                   <label for="voiceSelector" class="block text-sm font-medium text-gray-700">Voice Accent (TTS)</label>
+                   <select id="voiceSelector" class="mt-1 block w-full pl-3 pr-10 py-2 text-base border-gray-300 rounded-md shadow-sm">
+                       <option value="co.uk">British (Female)</option>
+                       <option value="com">American (Female)</option>
+                       <option value="com.au">Australian (Female)</option>
+                   </select>
+               </div>
+           </div>
+        </div>
+
+        <div class="grid grid-cols-1 lg:grid-cols-2 gap-8">
+            <!-- Coluna da Esquerda: Inputs -->
+            <div class="flex flex-col gap-6">
+                <div class="card">
+                    <h2 class="text-xl font-semibold mb-4 text-gray-700">1. Study from Text</h2>
+                    <div id="textEditor" contenteditable="true" spellcheck="true" lang="en" class="w-full p-4 border rounded-md min-h-[150px]"></div>
+                    <p class="text-sm text-right text-gray-500 mt-2">Characters: <span id="charCount">0</span>/10000</p>
+                    <div class="mt-4 border-t pt-4 flex flex-wrap gap-2 justify-between items-center">
+                        <button id="createCardButton" onclick="createFlashcardFromSelection()" class="btn btn-primary bg-green-600 hover:bg-green-700 disabled:opacity-50" disabled>+ Create Flashcard</button>
+                        <button id="playButton" onclick="handlePlay()" class="btn btn-primary" disabled>
+                            <span id="playText">Listen to Text</span>
+                            <div id="playSpinner" class="spinner ml-2 hidden"></div>
+                        </button>
+                    </div>
+                    <audio id="audioPlayer" controls class="w-full mt-4 hidden"></audio>
+                </div>
+
+                <div class="card">
+                    <h2 class="text-xl font-semibold mb-4 text-gray-700">2. Study from Image (Analysis)</h2>
+                    <input type="file" id="imageUploader" accept="image/*" class="block w-full text-sm text-gray-500 file:mr-4 file:py-2 file:px-4 file:rounded-full file:border-0 file:font-semibold file:bg-violet-50 file:text-violet-700 hover:file:bg-violet-100"/>
+                    <img id="imagePreview" src="" class="mt-4 rounded-lg hidden max-h-60 mx-auto" alt="Preview"/>
+                    <div id="imageAnalysisResult" class="mt-4"></div>
+                </div>
+                
+                 <div class="card">
+                    <h2 class="text-xl font-semibold mb-4 text-gray-700">3. Conversation Practice</h2>
+                    <div id="chatDisplay" class="flex flex-col space-y-2 mb-4"></div>
+                    <div class="flex gap-2">
+                        <input type="text" id="chatInput" class="flex-grow border rounded-lg px-3 py-2" placeholder="Type or use the microphone...">
+                        <button onclick="handleTextInput()" class="btn btn-primary bg-gray-500 hover:bg-gray-600">Send</button>
+                        <button id="micButton" onclick="handleVoiceInput()" class="btn btn-primary mic-button w-12 h-12 rounded-full">🎙️</button>
+                    </div>
+                </div>
+
+                <div class="card">
+                    <h2 class="text-xl font-semibold mb-4 text-gray-700">4. Image Generator (Nano Banana)</h2>
+                    <p class="text-sm text-gray-600 mb-2">Describe a scene in English for the AI to draw.</p>
+                    <div class="flex gap-2">
+                        <input type="text" id="imagePromptInput" class="flex-grow border rounded-lg px-3 py-2" placeholder="Ex: a blue cat reading a book on the moon">
+                        <button id="generateImageBtn" onclick="generateImage()" class="btn btn-primary">Generate</button>
+                    </div>
+                    <div id="imageResultContainer" class="mt-4 p-4 border rounded-lg bg-gray-50 min-h-[200px] flex items-center justify-center">
+                        <p class="text-gray-500 italic">Your image will appear here.</p>
+                    </div>
+                </div>
+                
+                <div class="card">
+                    <h2 class="text-xl font-semibold mb-4 text-gray-700">5. Content Discovery & Curation</h2>
+                    <div id="contentCuration" style="display: none;">
+                        <div class="mb-4">
+                            <h3 class="text-lg font-medium mb-2">🔍 Find Relevant Content</h3>
+                            <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mb-4">
+                                <div>
+                                    <label class="block text-sm font-medium text-gray-700 mb-1">Search Topic</label>
+                                    <input type="text" id="contentSearchInput" class="w-full border rounded-lg px-3 py-2" placeholder="e.g., cybersecurity, product management">
+                                </div>
+                                <div>
+                                    <label class="block text-sm font-medium text-gray-700 mb-1">Category</label>
+                                    <select id="contentCategorySelect" class="w-full border rounded-lg px-3 py-2">
+                                        <option value="">All Categories</option>
+                                        <option value="technology">Technology</option>
+                                        <option value="business">Business</option>
+                                        <option value="automotive">Automotive</option>
+                                        <option value="cybersecurity">Cybersecurity</option>
+                                        <option value="science">Science</option>
+                                    </select>
+                                </div>
+                            </div>
+                            <div class="flex gap-2 mb-4">
+                                <button onclick="searchContent()" class="btn btn-primary">🔍 Search Articles</button>
+                                <button onclick="getRecommendations()" class="btn bg-purple-500 hover:bg-purple-600 text-white">✨ AI Recommendations</button>
+                                <button onclick="showSavedArticles()" class="btn bg-green-500 hover:bg-green-600 text-white">📚 Saved Articles</button>
+                            </div>
+                        </div>
+                        
+                        <div id="contentResults" class="space-y-4">
+                            <div class="empty-state">
+                                <div class="empty-state-icon">🔍</div>
+                                <div class="empty-state-title">Discover Personalized Content</div>
+                                <div class="empty-state-description">Search for articles or get AI recommendations based on your interests and English level</div>
+                            </div>
+                        </div>
+                        
+                        <div class="mt-6 pt-4 border-t">
+                            <h3 class="text-lg font-medium mb-2">📝 Add Your Own Content</h3>
+                            <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mb-4">
+                                <input type="text" id="customContentTitle" class="border rounded-lg px-3 py-2" placeholder="Article Title">
+                                <input type="url" id="customContentUrl" class="border rounded-lg px-3 py-2" placeholder="URL (optional)">
+                            </div>
+                            <textarea id="customContentText" rows="4" class="w-full border rounded-lg px-3 py-2 mb-4" placeholder="Paste your text content here..."></textarea>
+                            <button onclick="saveCustomContent()" class="btn btn-primary">💾 Save Content</button>
+                        </div>
+                    </div>
+                    <div id="contentCurationLogin" class="text-center py-8">
+                        <div class="empty-state">
+                            <div class="empty-state-icon">🔐</div>
+                            <div class="empty-state-title">Login Required</div>
+                            <div class="empty-state-description">
+                                Please log in to access personalized content curation, save articles, and get AI-powered recommendations.
+                            </div>
+                            <button onclick="showAuthModal('login')" class="btn btn-primary mt-4">Login to Continue</button>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="card">
+                    <h2 class="text-xl font-semibold mb-4 text-gray-700">6. Interactive Writing Practice</h2>
+                    <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mb-4">
+                       <div>
+                           <label for="activityTypeSelector" class="block text-sm font-medium text-gray-700">Activity Type</label>
+                           <select id="activityTypeSelector" class="mt-1 block w-full pl-3 pr-10 py-2 text-base border-gray-300 rounded-md shadow-sm">
+                               <option value="translate_pt_en">Translate (PT to EN)</option>
+                               <option value="email_writing">Write Formal Email</option>
+                               <option value="summary_writing">Summarize Main Text</option>
+                               <option value="professional_conversation">Simulate Professional Conversation</option>
+                           </select>
+                       </div>
+                        <div class="flex items-end">
+                             <button id="generateActivityButton" onclick="generateActivity()" class="btn btn-primary w-full">Generate Activity</button>
+                        </div>
+                    </div>
+                    
+                    <div id="activityChatContainer" class="mt-4 border-t pt-4">
+                        <div id="activityChatDisplay">
+                            <p class="text-gray-500 italic">Your interactive exercise will appear here.</p>
+                        </div>
+                        <div id="activityResponseArea" class="mt-4 hidden">
+                            <label for="activityInput" class="block text-sm font-medium text-gray-700 mb-1">Your Answer:</label>
+                            <textarea id="activityInput" rows="4" class="w-full p-2 border rounded-md"></textarea>
+                            <button id="submitActivityBtn" onclick="submitActivityResponse()" class="btn btn-primary mt-2">Submit Answer</button>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Coluna da Direita: Painel Dinâmico -->
+            <div class="flex flex-col gap-6">
+                <!-- Study Analytics Panel (for logged users) -->
+                <div id="analyticsPanel" class="card" style="display: none;">
+                    <div class="flex justify-between items-center mb-4">
+                        <h2 class="text-xl font-semibold text-gray-700">📊 Your Progress</h2>
+                        <button onclick="toggleAnalytics()" class="text-gray-500 hover:text-gray-700">↕️</button>
+                    </div>
+                    <div id="analyticsContent">
+                        <div class="grid grid-cols-2 gap-4 mb-4">
+                            <div class="text-center p-4 bg-blue-50 rounded-lg">
+                                <div class="text-2xl font-bold text-blue-600" id="totalFlashcards">0</div>
+                                <div class="text-sm text-gray-600">Flashcards</div>
+                            </div>
+                            <div class="text-center p-4 bg-green-50 rounded-lg">
+                                <div class="text-2xl font-bold text-green-600" id="totalArticles">0</div>
+                                <div class="text-sm text-gray-600">Articles</div>
+                            </div>
+                        </div>
+                        <div class="text-center p-3 bg-purple-50 rounded-lg">
+                            <div class="text-lg font-semibold text-purple-600" id="currentLevel">B1</div>
+                            <div class="text-sm text-gray-600">Current Level</div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Study Planner Panel (for logged users) -->
+                <div id="studyPlannerPanel" class="card" style="display: none;">
+                    <h2 class="text-xl font-semibold mb-4 text-gray-700">🎯 Study Planner</h2>
+                    <div id="studyPlanContent">
+                        <div class="mb-4">
+                            <h3 class="font-medium mb-2">Quick Plan Generator</h3>
+                            <div class="grid grid-cols-1 gap-2 mb-3">
+                                <select id="targetLevelSelect" class="border rounded-lg px-3 py-2 text-sm">
+                                    <option value="A2">Target: A2 (Elementary)</option>
+                                    <option value="B1">Target: B1 (Intermediate)</option>
+                                    <option value="B2" selected>Target: B2 (Upper-Intermediate)</option>
+                                    <option value="C1">Target: C1 (Advanced)</option>
+                                    <option value="C2">Target: C2 (Proficient)</option>
+                                </select>
+                                <select id="weeklyHoursSelect" class="border rounded-lg px-3 py-2 text-sm">
+                                    <option value="3">3 hours/week</option>
+                                    <option value="5" selected>5 hours/week</option>
+                                    <option value="7">7 hours/week</option>
+                                    <option value="10">10 hours/week</option>
+                                </select>
+                            </div>
+                            <button onclick="generateStudyPlan()" class="btn btn-primary w-full text-sm">🚀 Generate Plan</button>
+                        </div>
+                        <div id="studyPlanResult" class="text-sm text-gray-600">
+                            Your personalized study plan will appear here
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Flashcards Panel -->
+                <div id="flashcardsPanel" class="card">
+                    <div class="flex justify-between items-center mb-4">
+                        <h2 class="text-xl font-semibold text-gray-700">Your Study Session</h2>
+                        <div class="flex items-center gap-2">
+                            <button id="loadFlashcardsBtn" onclick="showUserFlashcards()" class="btn bg-blue-100 text-blue-700 hover:bg-blue-200 text-sm" style="display: none;" title="Load your saved flashcards">📚 Load Saved</button>
+                            <div id="sessionStatus" class="text-sm">
+                                <span id="guestStatus" class="text-gray-500">Guest Mode - Progress not saved</span>
+                                <span id="userStatus" class="text-green-600" style="display: none;">✓ Progress being saved</span>
+                            </div>
+                        </div>
+                    </div>
+                    <div id="flashcardList" class="space-y-6">
+                        <div id="noCardsMessage" class="empty-state">
+                            <div class="empty-state-icon">📚</div>
+                            <div class="empty-state-title">No flashcards yet</div>
+                            <div class="empty-state-description">
+                                Select text from the editor or analyze an image to create your first flashcard!
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Auth Modal -->
+    <div id="authModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h2 id="authModalTitle">Login</h2>
+                <span class="close" onclick="hideAuthModal()">&times;</span>
+            </div>
+            <div class="modal-body">
+                <!-- Login Form -->
+                <form id="loginForm" class="auth-form active">
+                    <div class="form-group">
+                        <label for="loginEmail">Email</label>
+                        <input type="email" id="loginEmail" required>
+                    </div>
+                    <div class="form-group">
+                        <label for="loginPassword">Password</label>
+                        <input type="password" id="loginPassword" required>
+                    </div>
+                    <button type="submit" class="btn btn-primary w-full">Login</button>
+                    <p class="text-center mt-4 text-sm text-gray-600">
+                        Don't have an account? 
+                        <a href="#" onclick="switchAuthForm('register')" class="text-indigo-600 hover:text-indigo-800">Sign up</a>
+                    </p>
+                </form>
+                
+                <!-- Register Form -->
+                <form id="registerForm" class="auth-form">
+                    <div class="form-group">
+                        <label for="registerEmail">Email</label>
+                        <input type="email" id="registerEmail" required>
+                    </div>
+                    <div class="form-group">
+                        <label for="registerPassword">Password</label>
+                        <input type="password" id="registerPassword" required minlength="8">
+                        <small class="text-gray-500">At least 8 characters</small>
+                    </div>
+                    <div class="form-group">
+                        <label for="confirmPassword">Confirm Password</label>
+                        <input type="password" id="confirmPassword" required>
+                    </div>
+                    <button type="submit" class="btn btn-primary w-full">Create Account</button>
+                    <p class="text-center mt-4 text-sm text-gray-600">
+                        Already have an account? 
+                        <a href="#" onclick="switchAuthForm('login')" class="text-indigo-600 hover:text-indigo-800">Login</a>
+                    </p>
+                </form>
+            </div>
+        </div>
+    </div>
+
+<script>
+    // --- ELEMENTOS GLOBAIS ---
+    const modelSelector = document.getElementById('modelSelector');
+    const contextSelector = document.getElementById('contextSelector');
+    const voiceSelector = document.getElementById('voiceSelector');
+    const textEditor = document.getElementById('textEditor');
+    const createCardButton = document.getElementById('createCardButton');
+    const playButton = document.getElementById('playButton');
+    const audioPlayer = document.getElementById('audioPlayer');
+    const flashcardList = document.getElementById('flashcardList');
+    const noCardsMessage = document.getElementById('noCardsMessage');
+    const imageUploader = document.getElementById('imageUploader');
+    const imagePreview = document.getElementById('imagePreview');
+    const imageAnalysisResult = document.getElementById('imageAnalysisResult');
+    const chatDisplay = document.getElementById('chatDisplay');
+    const chatInput = document.getElementById('chatInput');
+    const micButton = document.getElementById('micButton');
+    const imagePromptInput = document.getElementById('imagePromptInput');
+    const generateImageBtn = document.getElementById('generateImageBtn');
+    const imageResultContainer = document.getElementById('imageResultContainer');
+    const activityTypeSelector = document.getElementById('activityTypeSelector');
+    const generateActivityButton = document.getElementById('generateActivityButton');
+    const activityChatDisplay = document.getElementById('activityChatDisplay');
+    const activityResponseArea = document.getElementById('activityResponseArea');
+    const activityInput = document.getElementById('activityInput');
+    const submitActivityBtn = document.getElementById('submitActivityBtn');
+    const toastContainer = document.getElementById('toastContainer');
+    
+    let chatHistory = [];
+    let recognition;
+    let isRecording = false;
+    let currentActivityPrompt = "";
+    let currentUser = null;
+
+    // --- SISTEMA DE TOAST NOTIFICATIONS ---
+    function showToast(message, type = 'info', duration = 5000) {
+        const toast = document.createElement('div');
+        toast.className = `toast ${type}`;
+        toast.innerHTML = `
+            <button class="toast-close" onclick="this.parentElement.remove()">&times;</button>
+            <div class="font-medium">${getToastTitle(type)}</div>
+            <div class="text-sm mt-1">${message}</div>
+        `;
+        
+        toastContainer.appendChild(toast);
+        
+        // Show animation
+        setTimeout(() => toast.classList.add('show'), 100);
+        
+        // Auto remove
+        setTimeout(() => {
+            toast.classList.remove('show');
+            setTimeout(() => toast.remove(), 300);
+        }, duration);
+    }
+    
+    function getToastTitle(type) {
+        const titles = {
+            'success': '✅ Success',
+            'error': '❌ Error', 
+            'warning': '⚠️ Warning',
+            'info': 'ℹ️ Info'
+        };
+        return titles[type] || 'Info';
+    }
+    
+    // --- ENHANCED ERROR HANDLING ---
+    async function handleApiRequest(url, options, errorContext = 'Request') {
+        try {
+            const response = await fetch(url, options);
+            
+            if (!response.ok) {
+                let errorMessage = `HTTP ${response.status}`;
+                try {
+                    const errorData = await response.json();
+                    errorMessage = errorData.error || errorMessage;
+                } catch (e) {
+                    // Use default HTTP error
+                }
+                throw new Error(errorMessage);
+            }
+            
+            return await response.json();
+        } catch (error) {
+            console.error(`${errorContext} failed:`, error);
+            
+            if (error.name === 'TypeError' && error.message.includes('fetch')) {
+                showToast('Network connection error. Please check your internet connection.', 'error');
+            } else if (error.message.includes('503')) {
+                showToast('Service temporarily unavailable. Please check API configuration.', 'warning');
+            } else {
+                showToast(`${errorContext} failed: ${error.message}`, 'error');
+            }
+            
+            throw error;
+        }
+    }
+    
+    // --- LOADING STATE MANAGEMENT ---
+    function setButtonLoading(button, loading, originalText = null) {
+        if (loading) {
+            button.disabled = true;
+            button.dataset.originalText = button.innerHTML;
+            button.innerHTML = '<div class="spinner mr-2"></div> Loading...';
+        } else {
+            button.disabled = false;
+            button.innerHTML = originalText || button.dataset.originalText || button.innerHTML;
+        }
+    }
+    
+    // --- INPUT VALIDATION ---
+    function validateInput(input, errorMessage) {
+        const value = input.value?.trim() || '';
+        const errorElement = input.parentNode.querySelector('.error-message');
+        
+        if (!value) {
+            input.classList.add('form-error');
+            if (!errorElement) {
+                const error = document.createElement('div');
+                error.className = 'error-message';
+                error.textContent = errorMessage;
+                input.parentNode.appendChild(error);
+            }
+            return false;
+        } else {
+            input.classList.remove('form-error');
+            if (errorElement) errorElement.remove();
+            return true;
+        }
+    }
+
+    // --- CARREGAMENTO DINÂMICO DE MODELOS ---
+    async function populateModelSelector() {
+        try {
+            const models = await handleApiRequest('/list-models', {}, 'Loading models');
+            modelSelector.innerHTML = '';
+            
+            const geminiGroup = document.createElement('optgroup');
+            geminiGroup.label = 'Google Gemini';
+            const groqGroup = document.createElement('optgroup');
+            groqGroup.label = 'Groq (Ultra Fast)';
+            
+            models.forEach(model => {
+                const option = document.createElement('option');
+                option.value = model.value;
+                option.textContent = model.name;
+                if (model.value.startsWith('gemini:')) {
+                    geminiGroup.appendChild(option);
+                } else if (model.value.startsWith('groq:')) {
+                    groqGroup.appendChild(option);
+                }
+            });
+            
+            modelSelector.appendChild(geminiGroup);
+            modelSelector.appendChild(groqGroup);
+            showToast('Models loaded successfully', 'success', 2000);
+        } catch (error) {
+            modelSelector.innerHTML = '<option>Error loading models</option>';
+        }
+    }
+
+    // --- FUNÇÕES DE ÁUDIO ---
+    async function fetchAudioBlob(text) {
+        const selectedTld = voiceSelector.value;
+        const response = await fetch('/tts-proxy', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ text: text, tld: selectedTld })
+        });
+        if (!response.ok) {
+            const err = await response.json();
+            throw new Error(err.error || `HTTP error! status: ${response.status}`);
+        }
+        return await response.blob();
+    }
+    
+    async function playAudio(text, event) {
+        if(event) event.stopPropagation();
+        if (!text || !text.trim()) {
+            showToast('No text to play', 'warning', 2000);
+            return;
+        }
+        
+        try {
+            const audioBlob = await fetchAudioBlob(text);
+            const audioUrl = URL.createObjectURL(audioBlob);
+            const audio = new Audio(audioUrl);
+            
+            audio.onplay = () => showToast('Playing audio...', 'info', 1000);
+            audio.onended = () => URL.revokeObjectURL(audioUrl);
+            audio.onerror = () => showToast('Failed to play audio', 'error');
+            
+            await audio.play();
+        } catch (error) { 
+            console.error('Error playing audio:', error);
+            showToast('Failed to generate audio. Please try again.', 'error');
+        }
+    }
+
+    // --- LÓGICA DO EDITOR ---
+    const charCount = document.getElementById('charCount');
+    const playText = document.getElementById('playText');
+    const playSpinner = document.getElementById('playSpinner');
+    textEditor.addEventListener('input', () => {
+        const len = textEditor.innerText.length;
+        charCount.textContent = `${len}/10000`;
+        playButton.disabled = len === 0;
+    });
+    textEditor.addEventListener('mouseup', () => {
+        createCardButton.disabled = !window.getSelection().toString().trim();
+    });
+    async function handlePlay() {
+        const text = textEditor.innerText.trim();
+        if (!text) {
+            showToast('Please enter some text first', 'warning');
+            return;
+        }
+        
+        if (text.length > 5000) {
+            showToast('Text is too long for audio generation. Please use shorter text.', 'warning');
+            return;
+        }
+        
+        setButtonLoading(playButton, true);
+        playText.textContent = 'Generating...';
+        playSpinner.classList.remove('hidden');
+        
+        try {
+            const audioBlob = await fetchAudioBlob(text);
+            const audioUrl = URL.createObjectURL(audioBlob);
+            audioPlayer.src = audioUrl;
+            audioPlayer.classList.remove('hidden');
+            
+            audioPlayer.onplay = () => showToast('Audio ready! Playing...', 'success', 1000);
+            audioPlayer.onended = () => URL.revokeObjectURL(audioUrl);
+            audioPlayer.onerror = () => showToast('Failed to play audio', 'error');
+            
+            await audioPlayer.play();
+        } catch (error) {
+            showToast('Failed to generate audio. Please check your connection and try again.', 'error');
+        } finally {
+            setButtonLoading(playButton, false);
+            playText.textContent = 'Listen to Text';
+            playSpinner.classList.add('hidden');
+        }
+    }
+
+    // --- TODAS AS OUTRAS FUNÇÕES ---
+    
+    // ATIVIDADES
+    async function generateActivity() {
+        const activityType = activityTypeSelector.value;
+        const context = contextSelector.value;
+        const sourceText = textEditor.innerText;
+        generateActivityButton.disabled = true;
+        generateActivityButton.innerHTML = '<div class="spinner mr-2"></div> Generating...';
+        activityChatDisplay.innerHTML = '<p class="text-gray-500 italic">Generating your exercise...</p>';
+        activityResponseArea.classList.add('hidden');
+        let prompt = "";
+        if (activityType === 'translate_pt_en') {
+            prompt = `Based on the '${context}' context, create one single sentence in Portuguese for me to translate into English.`;
+        } else if (activityType === 'email_writing') {
+            prompt = `Create a scenario for me to write a formal email, related to the '${context}' context. Give me clear instructions on what to write.`;
+        } else if (activityType === 'summary_writing') {
+            if (!sourceText) {
+                alert("Please paste text in the main editor to generate a summary activity.");
+                activityChatDisplay.innerHTML = '<p class="text-red-500">Please paste text in the editor in card #1 first.</p>';
+                generateActivityButton.disabled = false;
+                generateActivityButton.textContent = 'Generate Activity';
+                return;
+            }
+            prompt = `Your task is to summarize the following text in 2 or 3 sentences: "${sourceText}"`;
+        } else if (activityType === 'professional_conversation') {
+             prompt = `Start a professional role-playing conversation with me related to '${context}'. Ask me an open-ended question to begin.`;
+        }
+        try {
+            const response = await fetch('/explain-proxy', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: modelSelector.value,
+                    context_focus: context,
+                    custom_prompt: prompt
+                })
+            });
+            if (!response.ok) throw new Error((await response.json()).error);
+            const data = await response.json();
+            currentActivityPrompt = data.explanation;
+            activityChatDisplay.innerHTML = `<div class="ai-prompt"><strong>Your Task:</strong><p>${currentActivityPrompt}</p></div>`;
+            activityResponseArea.classList.remove('hidden');
+        } catch (error) {
+            activityChatDisplay.innerHTML = `<p class="text-red-600 font-semibold">Failed to generate activity: ${error.message}</p>`;
+        } finally {
+            generateActivityButton.disabled = false;
+            generateActivityButton.textContent = 'Generate Activity';
+        }
+    }
+    async function submitActivityResponse() {
+        const userResponse = activityInput.value.trim();
+        if (!userResponse) {
+            alert("Please write a response.");
+            return;
+        }
+        submitActivityBtn.disabled = true;
+        submitActivityBtn.innerHTML = '<div class="spinner mr-2"></div> Getting Feedback...';
+        const oldFeedback = activityChatDisplay.querySelector('.ai-feedback');
+        if(oldFeedback) oldFeedback.remove();
+        const oldResponse = activityChatDisplay.querySelector('.user-response-display');
+        if(oldResponse) oldResponse.remove();
+        const userResponseDiv = document.createElement('div');
+        userResponseDiv.className = 'user-response-display';
+        userResponseDiv.innerHTML = `<strong>Your Response:</strong><p>${userResponse}</p>`;
+        activityChatDisplay.appendChild(userResponseDiv);
+        try {
+            const response = await fetch('/activity-feedback', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: modelSelector.value,
+                    context_focus: contextSelector.value,
+                    original_prompt: currentActivityPrompt,
+                    user_response: userResponse
+                })
+            });
+            if (!response.ok) throw new Error((await response.json()).error);
+            const data = await response.json();
+            const feedbackDiv = document.createElement('div');
+            feedbackDiv.className = 'ai-feedback';
+            feedbackDiv.innerHTML = `<strong>Feedback:</strong><div class="prose prose-sm max-w-none">${marked.parse(data.feedback)}</div>`;
+            activityChatDisplay.appendChild(feedbackDiv);
+            activityInput.value = '';
+        } catch (error) {
+            const errorDiv = document.createElement('div');
+            errorDiv.className = 'ai-feedback';
+            errorDiv.innerHTML = `<p class="text-red-600 font-semibold">Failed to get feedback: ${error.message}</p>`;
+            activityChatDisplay.appendChild(errorDiv);
+        } finally {
+            submitActivityBtn.disabled = false;
+            submitActivityBtn.textContent = 'Submit Answer';
+        }
+    }
+    
+    // CONVERSAÇÃO
+    function initializeSpeechRecognition() {
+        window.SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
+        if (!window.SpeechRecognition) {
+            micButton.disabled = true;
+            micButton.textContent = '❌';
+            alert('Voice recognition API is not supported in this browser.');
+            return;
+        }
+        recognition = new SpeechRecognition();
+        recognition.lang = 'en-US';
+        recognition.interimResults = false;
+        recognition.continuous = false;
+        recognition.onresult = (event) => {
+            const transcript = event.results[0][0].transcript;
+            chatInput.value = transcript;
+            sendMessage(transcript);
+        };
+        recognition.onerror = (event) => { console.error('Voice recognition error:', event.error); };
+        recognition.onend = () => {
+            isRecording = false;
+            micButton.classList.remove('is-recording');
+            micButton.innerHTML = '🎙️';
+        };
+    }
+    function handleVoiceInput() {
+        if (isRecording) {
+            recognition.stop();
+        } else {
+            isRecording = true;
+            micButton.classList.add('is-recording');
+            micButton.innerHTML = '<div class="spinner"></div>';
+            recognition.start();
+        }
+    }
+    function handleTextInput() {
+        const message = chatInput.value.trim();
+        sendMessage(message);
+        chatInput.value = '';
+    }
+    chatInput.addEventListener('keypress', (e) => { if (e.key === 'Enter') handleTextInput(); });
+    async function sendMessage(message) {
+        if (!message) return;
+        appendMessage(message, 'user');
+        chatHistory.push({ role: 'user', content: message });
+        try {
+            const response = await fetch('/chat-with-ai', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ history: chatHistory, message: message })
+            });
+            if (!response.ok) throw new Error((await response.json()).error);
+            const data = await response.json();
+            appendMessage(data.response, 'ai');
+            chatHistory.push({ role: 'assistant', content: data.response });
+            playAudio(data.response);
+        } catch (error) {
+            appendMessage(`Chat error: ${error.message}`, 'ai');
+        }
+    }
+    function appendMessage(text, sender) {
+        const msg = document.createElement('div');
+        msg.className = `chat-message ${sender}-message`;
+        msg.textContent = text;
+        chatDisplay.appendChild(msg);
+        chatDisplay.scrollTop = chatDisplay.scrollHeight;
+    }
+    
+    // IMAGEM
+    imageUploader.addEventListener('change', (event) => {
+        const file = event.target.files[0];
+        if (!file) return;
+        const reader = new FileReader();
+        reader.onload = (e) => {
+            imagePreview.src = e.target.result;
+            imagePreview.classList.remove('hidden');
+            analyzeImage(e.target.result);
+        };
+        reader.readAsDataURL(file);
+    });
+    async function analyzeImage(base64Image) {
+        // Show skeleton loading
+        imageAnalysisResult.innerHTML = `
+            <div class="spinner-container">
+                <div class="spinner spinner-large !border-l-indigo-500 !border-gray-200"></div>
+                <p class="ml-3 text-gray-600">Analyzing image with AI...</p>
+            </div>
+            <div class="mt-4">
+                <div class="skeleton-text loading-skeleton mb-2"></div>
+                <div class="flex gap-2">
+                    <div class="skeleton-box loading-skeleton" style="width: 80px; height: 32px;"></div>
+                    <div class="skeleton-box loading-skeleton" style="width: 100px; height: 32px;"></div>
+                    <div class="skeleton-box loading-skeleton" style="width: 90px; height: 32px;"></div>
+                </div>
+            </div>`;
+            
+        try {
+            const vocabulary = await handleApiRequest('/analyze-image', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ 
+                    image: base64Image,
+                    model: modelSelector.value
+                })
+            }, 'Analyzing image');
+            
+            displayImageVocabulary(vocabulary);
+            showToast(`Found ${vocabulary.length} vocabulary items in the image!`, 'success');
+        } catch (error) {
+            imageAnalysisResult.innerHTML = `
+                <div class="empty-state">
+                    <div class="empty-state-icon">❌</div>
+                    <div class="empty-state-title">Analysis Failed</div>
+                    <div class="empty-state-description">Please try uploading the image again or check your connection.</div>
+                </div>`;
+        }
+    }
+    function displayImageVocabulary(vocabulary) {
+        imageAnalysisResult.innerHTML = `
+            <div class="fade-in">
+                <h3 class="font-semibold mb-3 text-gray-700">🎯 Suggested Vocabulary (${vocabulary.length} items)</h3>
+                <div class="flex flex-wrap gap-2" id="vocabularyButtons"></div>
+                <p class="text-xs text-gray-500 mt-3">Click any term to create a flashcard</p>
+            </div>`;
+            
+        const buttonContainer = document.getElementById('vocabularyButtons');
+        vocabulary.forEach(({ term, definition }, index) => {
+            const btn = document.createElement('button');
+            btn.className = 'btn bg-violet-100 text-violet-700 hover:bg-violet-200 text-sm slide-in';
+            btn.style.animationDelay = `${index * 0.1}s`;
+            btn.innerHTML = `${term} <span class="text-violet-500 ml-1">+</span>`;
+            btn.title = `${term}: ${definition}`;
+            btn.onclick = () => {
+                btn.disabled = true;
+                btn.innerHTML = '<div class="spinner mr-1"></div> Creating...';
+                createFlashcardFromSuggestion(term, definition);
+            };
+            buttonContainer.appendChild(btn);
+        });
+    }
+    async function generateImage() {
+        const prompt = imagePromptInput.value.trim();
+        if (!prompt) {
+            alert('Please enter a description for the image.');
+            return;
+        }
+        generateImageBtn.disabled = true;
+        generateImageBtn.innerHTML = '<div class="spinner mr-2"></div> Generating...';
+        imageResultContainer.innerHTML = `<div class="flex items-center justify-center p-4"><div class="spinner !border-l-indigo-500 !border-gray-200"></div><p class="ml-3 text-gray-600">Creating your image...</p></div>`;
+        try {
+            const response = await fetch('/generate-image', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ prompt: prompt })
+            });
+            if (!response.ok) throw new Error((await response.json()).error);
+            const data = await response.json();
+            imageResultContainer.innerHTML = `<img src="data:image/png;base64,${data.image_base64}" class="rounded-lg max-h-60 mx-auto" alt="AI-generated image"/>`;
+        } catch (error) {
+            imageResultContainer.innerHTML = `<p class="text-red-600 font-semibold">Failed to generate image: ${error.message}</p>`;
+        } finally {
+            generateImageBtn.disabled = false;
+            generateImageBtn.textContent = 'Generate';
+        }
+    }
+    
+    // FLASHCARDS
+    function createSkeletonFlashcard() {
+        const cardId = `skeleton-${Date.now()}`;
+        const container = document.createElement('div');
+        container.className = 'flashcard-container fade-in';
+        container.id = cardId;
+        container.innerHTML = `
+            <div class="flashcard-inner">
+                <div class="flashcard-front">
+                    <div>
+                        <div class="skeleton-text small loading-skeleton"></div>
+                        <div class="skeleton-text large loading-skeleton mt-4"></div>
+                        <div class="skeleton-text loading-skeleton"></div>
+                    </div>
+                    <div class="border-t pt-3 mt-3">
+                        <div class="skeleton-text loading-skeleton"></div>
+                        <div class="skeleton-text small loading-skeleton mt-2"></div>
+                    </div>
+                </div>
+            </div>`;
+        return container;
+    }
+    
+    async function createFlashcard(word, context, definition = null) {
+        if (!word || !word.trim()) {
+            showToast('Please select a word first', 'warning');
+            return;
+        }
+        
+        // Hide empty state and show skeleton
+        noCardsMessage.classList.add('hidden');
+        const skeletonCard = createSkeletonFlashcard();
+        flashcardList.prepend(skeletonCard);
+        
+        const btn = definition ? null : createCardButton;
+        if (btn) setButtonLoading(btn, true);
+        
+        try {
+            const cardData = await handleApiRequest('/explain-proxy', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    word: word.trim(),
+                    context: context || 'General context',
+                    for_flashcard: true,
+                    model: modelSelector.value,
+                    context_focus: contextSelector.value
+                })
+            }, 'Creating flashcard');
+            
+            if(definition && !cardData.definition) cardData.definition = definition;
+            
+            // Remove skeleton and add real card
+            skeletonCard.remove();
+            renderFlashcard(cardData);
+            
+            // Show appropriate message based on auth status
+            if (currentUser) {
+                showToast(`Flashcard for "${word}" created and saved to your account!`, 'success');
+            } else {
+                showToast(`Flashcard for "${word}" created! Login to save your progress.`, 'success');
+            }
+        } catch (error) {
+            // Remove skeleton on error
+            skeletonCard.remove();
+            // Show empty state if no cards left
+            if (flashcardList.children.length === 1) {
+                noCardsMessage.classList.remove('hidden');
+            }
+        } finally {
+            if (btn) setButtonLoading(btn, false);
+        }
+    }
+    function createFlashcardFromSelection() {
+        const selection = window.getSelection().toString().trim();
+        if (selection) createFlashcard(selection, textEditor.innerText);
+    }
+    function createFlashcardFromSuggestion(term, definition) {
+        createFlashcard(term, `(From image analysis) A visual representation of ${term}.`, definition);
+    }
+    function renderFlashcard(data) {
+        noCardsMessage.classList.add('hidden');
+        const cardId = `card-${Date.now()}`;
+        const container = document.createElement('div');
+        container.className = 'flashcard-container';
+        container.id = cardId;
+        
+        // Calculate dynamic height based on content length
+        const totalLength = (data.gapped_sentence?.length || 0) + 
+                           (data.translation?.length || 0) + 
+                           (data.definition?.length || 0) + 
+                           (data.context_sentence?.length || 0);
+        
+        let minHeight = 280;
+        if (totalLength > 300) minHeight = 350;  
+        if (totalLength > 500) minHeight = 420;  
+        if (totalLength > 800) minHeight = 500;  
+        
+        // Responsive height adjustment
+        if (window.innerWidth <= 768) {
+            minHeight = Math.max(250, minHeight * 0.85);
+        }
+        if (window.innerWidth <= 480) {
+            minHeight = Math.max(220, minHeight * 0.75);
+        }
+        
+        container.style.minHeight = `${minHeight}px`;
+        const fallback = 'Info not generated';
+        container.innerHTML = `
+            <button class="delete-btn" onclick="deleteFlashcard('${cardId}', event)" title="Delete flashcard">🗑️</button>
+            <div class="flashcard-inner">
+                <div class="flashcard-front">
+                     <div>
+                        <div class="text-sm text-gray-600 mb-2">Context Sentence:</div>
+                        <div class="flashcard-text text-lg text-center text-gray-800">${data.gapped_sentence || fallback}</div>
+                    </div>
+                    <div class="border-t pt-3 mt-3 text-center">
+                        <strong class="text-indigo-600">Hint (PT):</strong> 
+                        <div class="flashcard-text mt-1">${data.translation || fallback}</div>
+                    </div>
+                    <div class="text-xs text-center text-gray-400 mt-4">👆 Click to see the answer</div>
+                </div>
+                <div class="flashcard-back">
+                    <div>
+                        <h3 class="text-xl font-bold text-center text-indigo-600 mb-2">${data.term || 'Term'}</h3>
+                        <div class="flex items-center justify-center gap-2 text-gray-600 italic mb-3">
+                            <button class="audio-btn" onclick="playAudio('${(data.context_sentence || '').replace(/'/g, "\\'")}', event)" title="Listen to pronunciation">🔊</button>
+                            <span class="flashcard-text">${data.context_sentence || fallback}</span>
+                        </div>
+                        <div class="text-sm text-gray-800"><strong class="font-semibold">Definition:</strong> 
+                            <div class="flashcard-text mt-1">${data.definition || fallback}</div>
+                        </div>
+                    </div>
+                    <div class="border-t mt-3 pt-3">
+                        <h4 class="text-sm font-semibold text-center">Practice Your Pronunciation</h4>
+                        <div class="flex justify-center items-center gap-2 mt-2">
+                            <button class="btn btn-primary w-12 h-12 rounded-full mic-button" onclick="handlePronunciationPractice(this, '${(data.context_sentence || '').replace(/'/g, "\\'")}', event)" title="Record your pronunciation">🎙️</button>
+                        </div>
+                        <div class="text-xs text-gray-600 p-2 mt-2 bg-gray-50 rounded-md min-h-[40px] flashcard-text" data-feedback-area>Click the microphone to practice pronunciation</div>
+                    </div>
+                </div>
+            </div>`;
+        container.classList.add('fade-in');
+        flashcardList.prepend(container);
+        
+        container.addEventListener('click', (e) => {
+            if(e.target.tagName !== 'BUTTON' && !e.target.closest('button')) {
+                 container.classList.toggle('flipped');
+            }
+        });
+    }
+    function deleteFlashcard(cardId, event) {
+        event.stopPropagation();
+        const cardToDelete = document.getElementById(cardId);
+        if (cardToDelete) {
+            cardToDelete.remove();
+        }
+        if (flashcardList.children.length === 1) {
+            noCardsMessage.classList.remove('hidden');
+        }
+    }
+    async function handlePronunciationPractice(button, targetText, event) {
+        event.stopPropagation();
+        const feedbackArea = button.closest('.flashcard-back').querySelector('[data-feedback-area]');
+        const practiceRecognition = new SpeechRecognition();
+        practiceRecognition.lang = 'en-US';
+        button.innerHTML = '<div class="spinner"></div>';
+        button.disabled = true;
+        feedbackArea.textContent = 'Listening...';
+        practiceRecognition.start();
+        practiceRecognition.onresult = async (e) => {
+            const userText = e.results[0][0].transcript;
+            feedbackArea.textContent = `You said: "${userText}". Analyzing...`;
+            try {
+                const response = await fetch('/pronunciation-feedback', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ target_text: targetText, user_text: userText })
+                });
+                if (!response.ok) throw new Error((await response.json()).error);
+                const data = await response.json();
+                feedbackArea.innerHTML = `<strong>Feedback:</strong> ${data.feedback}`;
+            } catch (error) {
+                feedbackArea.textContent = `Analysis error: ${error.message}`;
+            } finally {
+                button.innerHTML = '🎙️';
+                button.disabled = false;
+            }
+        };
+        practiceRecognition.onerror = (e) => {
+            feedbackArea.textContent = `Recording error: ${e.error}`;
+            button.innerHTML = '🎙️';
+            button.disabled = false;
+        };
+    }
+    
+    // --- AUTHENTICATION FUNCTIONS ---
+    
+    async function checkAuthStatus() {
+        try {
+            const response = await fetch('/auth/check');
+            const data = await response.json();
+            
+            if (data.authenticated) {
+                currentUser = data.user;
+                showAuthenticatedState();
+                // Load user settings into selectors
+                if (data.user.settings) {
+                    loadUserSettings(data.user.settings);
+                }
+            } else {
+                showGuestState();
+            }
+        } catch (error) {
+            console.error('Auth check failed:', error);
+            showGuestState();
+        }
+    }
+    
+    function showAuthenticatedState() {
+        document.getElementById('guestAuth').style.display = 'none';
+        document.getElementById('userAuth').style.display = 'block';
+        document.getElementById('userEmail').textContent = currentUser.email;
+        document.getElementById('userAvatar').textContent = currentUser.email.charAt(0).toUpperCase();
+        
+        // Update session status
+        document.getElementById('guestStatus').style.display = 'none';
+        document.getElementById('userStatus').style.display = 'inline';
+        document.getElementById('loadFlashcardsBtn').style.display = 'inline-block';
+        
+        // Show advanced panels
+        document.getElementById('contentCuration').style.display = 'block';
+        document.getElementById('contentCurationLogin').style.display = 'none';
+        document.getElementById('analyticsPanel').style.display = 'block';
+        document.getElementById('studyPlannerPanel').style.display = 'block';
+        
+        // Load analytics and study plan
+        loadAnalytics();
+        loadCurrentStudyPlan();
+        
+        showToast(`Welcome back, ${currentUser.email}!`, 'success', 3000);
+    }
+    
+    function showGuestState() {
+        document.getElementById('guestAuth').style.display = 'flex';
+        document.getElementById('userAuth').style.display = 'none';
+        
+        // Update session status
+        document.getElementById('guestStatus').style.display = 'inline';
+        document.getElementById('userStatus').style.display = 'none';
+        document.getElementById('loadFlashcardsBtn').style.display = 'none';
+        
+        // Hide advanced panels
+        document.getElementById('contentCuration').style.display = 'none';
+        document.getElementById('contentCurationLogin').style.display = 'block';
+        document.getElementById('analyticsPanel').style.display = 'none';
+        document.getElementById('studyPlannerPanel').style.display = 'none';
+        
+        currentUser = null;
+    }
+    
+    function loadUserSettings(settings) {
+        if (settings.preferred_model) modelSelector.value = settings.preferred_model;
+        if (settings.context_focus) contextSelector.value = settings.context_focus;
+        if (settings.voice_accent) voiceSelector.value = settings.voice_accent;
+    }
+    
+    function showAuthModal(type = 'login') {
+        document.getElementById('authModal').classList.add('show');
+        switchAuthForm(type);
+    }
+    
+    function hideAuthModal() {
+        document.getElementById('authModal').classList.remove('show');
+        // Clear forms
+        document.getElementById('loginForm').reset();
+        document.getElementById('registerForm').reset();
+    }
+    
+    function switchAuthForm(type) {
+        const loginForm = document.getElementById('loginForm');
+        const registerForm = document.getElementById('registerForm');
+        const title = document.getElementById('authModalTitle');
+        
+        if (type === 'login') {
+            loginForm.classList.add('active');
+            registerForm.classList.remove('active');
+            title.textContent = 'Login';
+        } else {
+            registerForm.classList.add('active');
+            loginForm.classList.remove('active');
+            title.textContent = 'Create Account';
+        }
+    }
+    
+    function toggleUserMenu() {
+        document.getElementById('userAuth').classList.toggle('show');
+    }
+    
+    // Close user menu when clicking outside
+    document.addEventListener('click', (e) => {
+        if (!e.target.closest('.user-menu')) {
+            document.getElementById('userAuth').classList.remove('show');
+        }
+    });
+    
+    // Login form submission
+    document.getElementById('loginForm').addEventListener('submit', async (e) => {
+        e.preventDefault();
+        const email = document.getElementById('loginEmail').value;
+        const password = document.getElementById('loginPassword').value;
+        
+        const submitBtn = e.target.querySelector('button[type="submit"]');
+        setButtonLoading(submitBtn, true);
+        
+        try {
+            const data = await handleApiRequest('/login', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ email, password })
+            }, 'Logging in');
+            
+            currentUser = data.user;
+            hideAuthModal();
+            showAuthenticatedState();
+            
+            if (data.user.settings) {
+                loadUserSettings(data.user.settings);
+            }
+            
+        } catch (error) {
+            // Error already handled by handleApiRequest
+        } finally {
+            setButtonLoading(submitBtn, false);
+        }
+    });
+    
+    // Register form submission
+    document.getElementById('registerForm').addEventListener('submit', async (e) => {
+        e.preventDefault();
+        const email = document.getElementById('registerEmail').value;
+        const password = document.getElementById('registerPassword').value;
+        const confirmPassword = document.getElementById('confirmPassword').value;
+        
+        if (password !== confirmPassword) {
+            showToast('Passwords do not match', 'error');
+            return;
+        }
+        
+        const submitBtn = e.target.querySelector('button[type="submit"]');
+        setButtonLoading(submitBtn, true);
+        
+        try {
+            const data = await handleApiRequest('/register', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ email, password })
+            }, 'Creating account');
+            
+            hideAuthModal();
+            showToast('Account created! Please check your email to confirm your account.', 'success', 8000);
+            
+        } catch (error) {
+            // Error already handled by handleApiRequest
+        } finally {
+            setButtonLoading(submitBtn, false);
+        }
+    });
+    
+    async function logout() {
+        try {
+            await handleApiRequest('/logout', {
+                method: 'POST'
+            }, 'Logging out');
+            
+            showGuestState();
+            showToast('Logged out successfully', 'info');
+            
+        } catch (error) {
+            // Error already handled by handleApiRequest
+        }
+    }
+    
+    async function showUserSettings() {
+        if (!currentUser) return;
+        
+        document.getElementById('userAuth').classList.remove('show');
+        
+        // Simple settings update using current form values
+        const settings = {
+            preferred_model: modelSelector.value,
+            context_focus: contextSelector.value,
+            voice_accent: voiceSelector.value,
+            daily_goal: 10, // Default
+            notification_enabled: true // Default
+        };
+        
+        try {
+            await handleApiRequest('/user/settings', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(settings)
+            }, 'Saving settings');
+            
+            showToast('Settings saved successfully!', 'success');
+        } catch (error) {
+            // Error already handled
+        }
+    }
+    
+    async function showUserFlashcards() {
+        if (!currentUser) return;
+        
+        document.getElementById('userAuth').classList.remove('show');
+        
+        try {
+            const data = await handleApiRequest('/user/flashcards', {}, 'Loading your flashcards');
+            
+            // Clear current flashcards
+            flashcardList.innerHTML = '';
+            
+            if (data.flashcards && data.flashcards.length > 0) {
+                data.flashcards.forEach(card => {
+                    const flashcardData = {
+                        term: card.term,
+                        translation: card.translation,
+                        context_sentence: card.context_sentence,
+                        gapped_sentence: card.gapped_sentence,
+                        definition: card.definition
+                    };
+                    renderFlashcard(flashcardData);
+                });
+                showToast(`Loaded ${data.flashcards.length} saved flashcards`, 'success');
+            } else {
+                noCardsMessage.classList.remove('hidden');
+                showToast('No saved flashcards found', 'info');
+            }
+            
+        } catch (error) {
+            noCardsMessage.classList.remove('hidden');
+        }
+    }
+    
+    // --- CONTENT CURATION FUNCTIONS ---
+    
+    async function searchContent() {
+        if (!currentUser) {
+            showToast('Please log in to search content', 'warning');
+            return;
+        }
+        
+        const query = document.getElementById('contentSearchInput').value.trim();
+        const category = document.getElementById('contentCategorySelect').value;
+        
+        if (!query) {
+            showToast('Please enter a search topic', 'warning');
+            return;
+        }
+        
+        const resultsContainer = document.getElementById('contentResults');
+        resultsContainer.innerHTML = '<div class="spinner-container"><div class="spinner spinner-large"></div><p class="ml-3">Searching for relevant content...</p></div>';
+        
+        try {
+            const data = await handleApiRequest('/content/search', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ query, category })
+            }, 'Searching content');
+            
+            displayContentResults(data.results);
+        } catch (error) {
+            resultsContainer.innerHTML = '<div class="text-red-600">Failed to search content. Please try again.</div>';
+        }
+    }
+    
+    async function getRecommendations() {
+        if (!currentUser) {
+            showToast('Please log in to get recommendations', 'warning');
+            return;
+        }
+        
+        const resultsContainer = document.getElementById('contentResults');
+        resultsContainer.innerHTML = '<div class="spinner-container"><div class="spinner spinner-large"></div><p class="ml-3">Generating AI recommendations...</p></div>';
+        
+        try {
+            const data = await handleApiRequest('/content/recommendations', {}, 'Getting recommendations');
+            displayRecommendations(data.recommendations);
+        } catch (error) {
+            resultsContainer.innerHTML = '<div class="text-red-600">Failed to get recommendations. Please try again.</div>';
+        }
+    }
+    
+    function displayContentResults(results) {
+        const container = document.getElementById('contentResults');
+        
+        if (!results || results.length === 0) {
+            container.innerHTML = `
+                <div class="empty-state">
+                    <div class="empty-state-icon">🔍</div>
+                    <div class="empty-state-title">No Content Found</div>
+                    <div class="empty-state-description">Try different search terms or check your interests settings</div>
+                </div>`;
+            return;
+        }
+        
+        container.innerHTML = results.map(result => `
+            <div class="content-item fade-in">
+                <div class="content-item-title">${result.title}</div>
+                <div class="content-item-meta">
+                    <span class="difficulty-badge difficulty-${getDifficultyClass(result.estimated_difficulty || 3)}">
+                        Level ${result.estimated_difficulty || 3}
+                    </span>
+                    <span class="ml-2">${result.source}</span>
+                    ${result.published ? `<span class="ml-2">${new Date(result.published).toLocaleDateString()}</span>` : ''}
+                </div>
+                <div class="content-item-summary">${result.summary}</div>
+                <div class="flex gap-2 mt-3">
+                    <button onclick="extractAndSaveContent('${result.url}', '${result.title.replace(/'/g, "\\'")}')" class="btn bg-green-500 hover:bg-green-600 text-white text-sm">📖 Read & Save</button>
+                    <a href="${result.url}" target="_blank" class="btn bg-gray-500 hover:bg-gray-600 text-white text-sm">🔗 Open Original</a>
+                </div>
+            </div>
+        `).join('');
+    }
+    
+    function displayRecommendations(recommendations) {
+        const container = document.getElementById('contentResults');
+        
+        if (!recommendations || recommendations.length === 0) {
+            container.innerHTML = `
+                <div class="empty-state">
+                    <div class="empty-state-icon">🤖</div>
+                    <div class="empty-state-title">No Recommendations</div>
+                    <div class="empty-state-description">Update your interests in settings to get better recommendations</div>
+                </div>`;
+            return;
+        }
+        
+        container.innerHTML = `
+            <h3 class="text-lg font-semibold mb-4 text-purple-600">✨ AI Recommendations for You</h3>
+        ` + recommendations.map(rec => `
+            <div class="content-item fade-in border-purple-200">
+                <div class="content-item-title text-purple-700">${rec.topic}</div>
+                <div class="content-item-meta">
+                    <span class="difficulty-badge difficulty-${getDifficultyClass(rec.difficulty)}">
+                        ${rec.difficulty}
+                    </span>
+                    <span class="ml-2">AI Recommended</span>
+                </div>
+                <div class="content-item-summary">${rec.reason}</div>
+                <div class="flex gap-2 mt-3">
+                    <button onclick="searchSpecificTopic('${rec.topic.replace(/'/g, "\\'")}')" class="btn bg-purple-500 hover:bg-purple-600 text-white text-sm">🔍 Find Articles</button>
+                </div>
+            </div>
+        `).join('');
+    }
+    
+    function getDifficultyClass(level) {
+        if (level <= 2) return 'easy';
+        if (level <= 4) return 'medium';
+        return 'hard';
+    }
+    
+    async function extractAndSaveContent(url, title) {
+        try {
+            showToast('Extracting content...', 'info', 2000);
+            
+            const extractData = await handleApiRequest('/content/extract', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ url })
+            }, 'Extracting content');
+            
+            if (extractData.success) {
+                const saveData = await handleApiRequest('/content/save', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        title: extractData.title || title,
+                        content: extractData.content,
+                        source_url: url,
+                        source_type: 'web_search'
+                    })
+                }, 'Saving content');
+                
+                showToast('Content saved successfully!', 'success');
+                loadAnalytics(); // Refresh analytics
+            }
+        } catch (error) {
+            // Error already handled by handleApiRequest
+        }
+    }
+    
+    async function saveCustomContent() {
+        if (!currentUser) {
+            showToast('Please log in to save content', 'warning');
+            return;
+        }
+        
+        const title = document.getElementById('customContentTitle').value.trim();
+        const content = document.getElementById('customContentText').value.trim();
+        const url = document.getElementById('customContentUrl').value.trim();
+        
+        if (!title || !content) {
+            showToast('Please provide both title and content', 'warning');
+            return;
+        }
+        
+        try {
+            await handleApiRequest('/content/save', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    title,
+                    content,
+                    source_url: url || null,
+                    source_type: 'manual'
+                })
+            }, 'Saving content');
+            
+            // Clear form
+            document.getElementById('customContentTitle').value = '';
+            document.getElementById('customContentText').value = '';
+            document.getElementById('customContentUrl').value = '';
+            
+            showToast('Content saved successfully!', 'success');
+            loadAnalytics(); // Refresh analytics
+        } catch (error) {
+            // Error already handled
+        }
+    }
+    
+    async function showSavedArticles() {
+        if (!currentUser) return;
+        
+        try {
+            const data = await handleApiRequest('/content/articles', {}, 'Loading saved articles');
+            
+            const container = document.getElementById('contentResults');
+            
+            if (!data.articles || data.articles.length === 0) {
+                container.innerHTML = `
+                    <div class="empty-state">
+                        <div class="empty-state-icon">📚</div>
+                        <div class="empty-state-title">No Saved Articles</div>
+                        <div class="empty-state-description">Search and save articles to build your personal library</div>
+                    </div>`;
+                return;
+            }
+            
+            container.innerHTML = `
+                <h3 class="text-lg font-semibold mb-4 text-green-600">📚 Your Saved Articles (${data.articles.length})</h3>
+            ` + data.articles.map(article => `
+                <div class="content-item fade-in">
+                    <div class="content-item-title">${article.title}</div>
+                    <div class="content-item-meta">
+                        <span class="difficulty-badge difficulty-medium">${article.word_count} words</span>
+                        <span class="ml-2">${new Date(article.created_at).toLocaleDateString()}</span>
+                        ${article.category ? `<span class="ml-2">${article.category}</span>` : ''}
+                    </div>
+                    <div class="content-item-summary">${article.content.substring(0, 150)}...</div>
+                    <div class="flex gap-2 mt-3">
+                        <button onclick="loadArticleForStudy('${article.id}', '${article.title.replace(/'/g, "\\'")}')" class="btn btn-primary text-sm">📖 Study This</button>
+                        ${article.source_url ? `<a href="${article.source_url}" target="_blank" class="btn bg-gray-500 hover:bg-gray-600 text-white text-sm">🔗 Original</a>` : ''}
+                    </div>
+                </div>
+            `).join('');
+        } catch (error) {
+            // Error already handled
+        }
+    }
+    
+    function loadArticleForStudy(articleId, title) {
+        // Load the article content into the text editor
+        showToast(`Loading "${title}" for study...`, 'info');
+        // This would load the full article content - simplified for now
+        showToast('Article loaded! You can now create flashcards from it.', 'success');
+    }
+    
+    function searchSpecificTopic(topic) {
+        document.getElementById('contentSearchInput').value = topic;
+        searchContent();
+    }
+    
+    // --- ANALYTICS FUNCTIONS ---
+    
+    async function loadAnalytics() {
+        if (!currentUser) return;
+        
+        try {
+            const data = await handleApiRequest('/analytics/dashboard', {}, 'Loading analytics');
+            
+            document.getElementById('totalFlashcards').textContent = data.analytics.total_flashcards || 0;
+            document.getElementById('totalArticles').textContent = data.analytics.total_articles || 0;
+            document.getElementById('currentLevel').textContent = data.analytics.user_level || 'B1';
+        } catch (error) {
+            // Error already handled
+        }
+    }
+    
+    function toggleAnalytics() {
+        const content = document.getElementById('analyticsContent');
+        content.style.display = content.style.display === 'none' ? 'block' : 'none';
+    }
+    
+    // --- STUDY PLANNER FUNCTIONS ---
+    
+    async function generateStudyPlan() {
+        if (!currentUser) return;
+        
+        try {
+            const planData = {
+                current_level: currentUser.english_level || 'B1',
+                target_level: document.getElementById('targetLevelSelect')?.value || 'B2',
+                weekly_hours: parseInt(document.getElementById('weeklyHoursSelect')?.value || 5),
+                context_focus: currentUser.context_focus || 'General/Social',
+                study_goals: []
+            };
+
+            showLoading('Generating your personalized study plan...');
+            
+            const response = await fetch('/study-plan/create', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(planData)
+            });
+
+            const result = await response.json();
+            hideLoading();
+
+            if (result.success) {
+                displayStudyPlan(result.plan);
+                showToast('Study plan generated successfully!', 'success');
+            } else {
+                showToast('Failed to generate study plan: ' + result.error, 'error');
+            }
+        } catch (error) {
+            hideLoading();
+            console.error('Error generating study plan:', error);
+            showToast('Error generating study plan', 'error');
+        }
+    }
+
+    async function loadCurrentStudyPlan() {
+        if (!currentUser) return;
+        
+        try {
+            const response = await fetch('/study-plan/current');
+            const result = await response.json();
+
+            if (result.success && result.plan) {
+                displayStudyPlan(result.plan);
+                loadStudyProgress();
+            }
+        } catch (error) {
+            console.error('Error loading study plan:', error);
+        }
+    }
+
+    async function loadStudyProgress() {
+        if (!currentUser) return;
+        
+        try {
+            const response = await fetch('/study-plan/progress');
+            const result = await response.json();
+
+            if (result.success && result.progress) {
+                displayStudyProgress(result.progress);
+            }
+        } catch (error) {
+            console.error('Error loading study progress:', error);
+        }
+    }
+
+    async function completeActivity(planId, activityId, durationMinutes) {
+        if (!currentUser) return;
+        
+        try {
+            const notes = prompt('Any notes about this activity? (optional)') || '';
+            
+            const response = await fetch('/study-plan/activity/complete', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    plan_id: planId,
+                    activity_id: activityId,
+                    duration_minutes: durationMinutes,
+                    notes: notes
+                })
+            });
+
+            const result = await response.json();
+
+            if (result.success) {
+                showToast('Activity completed successfully!', 'success');
+                
+                // Update the UI
+                const activityCard = document.querySelector(`[data-activity-id="${activityId}"]`);
+                if (activityCard) {
+                    activityCard.classList.add('completed');
+                    const button = activityCard.querySelector('.complete-activity-btn');
+                    if (button) {
+                        button.textContent = '✅ Completed';
+                        button.disabled = true;
+                    }
+                }
+                
+                // Refresh progress
+                loadStudyProgress();
+            } else {
+                showToast('Failed to complete activity', 'error');
+            }
+        } catch (error) {
+            console.error('Error completing activity:', error);
+            showToast('Error completing activity', 'error');
+        }
+    }
+
+    function displayStudyPlan(plan) {
+        const container = document.getElementById('studyPlanResult');
+        if (!container) return;
+
+        container.innerHTML = `
+            <div class="study-plan-container">
+                <div class="study-plan-header">
+                    <h3>📅 Your Personalized Study Plan</h3>
+                    <div class="plan-overview grid grid-cols-2 gap-4 mt-4">
+                        <div class="plan-stat">
+                            <strong>Current Level:</strong> ${plan.current_level}
+                        </div>
+                        <div class="plan-stat">
+                            <strong>Target Level:</strong> ${plan.target_level}
+                        </div>
+                        <div class="plan-stat">
+                            <strong>Weekly Hours:</strong> ${plan.weekly_hours}h
+                        </div>
+                        <div class="plan-stat">
+                            <strong>Duration:</strong> ${plan.estimated_weeks} weeks
+                        </div>
+                    </div>
+                </div>
+
+                <div class="study-tips mt-6">
+                    <h4 class="font-medium mb-2">💡 Personalized Study Tips</h4>
+                    <ul class="space-y-1">
+                        ${plan.study_tips.map(tip => `<li class="text-sm text-gray-600">${tip}</li>`).join('')}
+                    </ul>
+                </div>
+
+                <div class="weekly-activities mt-6">
+                    <h4 class="font-medium mb-3">📚 Weekly Activities</h4>
+                    <div class="activities-grid space-y-3">
+                        ${plan.activities.slice(0, 6).map(activity => `
+                            <div class="activity-card bg-gray-50 p-3 rounded-lg" data-activity-id="${activity.id}">
+                                <div class="activity-header flex items-center gap-2 mb-2">
+                                    <span class="text-lg">${activity.icon}</span>
+                                    <strong class="text-sm">${activity.title}</strong>
+                                </div>
+                                <div class="activity-details text-xs text-gray-600">
+                                    <p><strong>Duration:</strong> ${activity.duration_minutes} minutes</p>
+                                    <p><strong>Day:</strong> ${['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][activity.day_of_week]}</p>
+                                </div>
+                                <button class="complete-activity-btn mt-2 bg-green-500 text-white px-3 py-1 rounded text-xs hover:bg-green-600" 
+                                        onclick="completeActivity('${plan.db_id || plan.id}', '${activity.id}', ${activity.duration_minutes})">
+                                    ✅ Mark Complete
+                                </button>
+                            </div>
+                        `).join('')}
+                    </div>
+                </div>
+
+                <div class="milestones mt-6">
+                    <h4 class="font-medium mb-3">🎯 Study Milestones</h4>
+                    <div class="milestones-list space-y-2">
+                        ${plan.milestones.slice(0, 3).map(milestone => `
+                            <div class="milestone-item flex items-center gap-3 p-2 bg-blue-50 rounded ${milestone.completed ? 'completed opacity-75' : ''}">
+                                <div class="milestone-week bg-blue-500 text-white px-2 py-1 rounded text-xs">Week ${milestone.week}</div>
+                                <div class="milestone-content flex-1">
+                                    <strong class="text-sm">${milestone.title}</strong>
+                                    <p class="text-xs text-gray-600">${milestone.description}</p>
+                                </div>
+                            </div>
+                        `).join('')}
+                    </div>
+                </div>
+            </div>
+        `;
+
+        container.classList.remove('hidden');
+    }
+
+    function displayStudyProgress(progress) {
+        // This would be called to show progress in analytics section
+        console.log('Study progress:', progress);
+    }
+    
+    // --- INICIALIZAÇÃO ---
+    document.addEventListener('DOMContentLoaded', () => {
+        checkAuthStatus();
+        populateModelSelector();
+        initializeSpeechRecognition();
+    });
+</script>
+
+</body>
+</html>
+

requeriments.txt

@@ -0,0 +1,16 @@
+flask
+flask-session
+gtts
+google-generativeai
+groq
+requests
+Pillow
+werkzeug
+email-validator
+beautifulsoup4
+feedparser
+matplotlib
+plotly
+pandas
+numpy
+psutil

run.py

@@ -0,0 +1,95 @@
+# run.py - Production startup script for English Helper
+
+import os
+import sys
+from app import app
+from database import init_db
+
+def setup_environment():
+    """Setup environment variables and configuration"""
+    # Set default environment variables if not present
+    if not os.environ.get('SECRET_KEY'):
+        os.environ['SECRET_KEY'] = 'dev-key-change-in-production'
+    
+    # Create data directory if it doesn't exist
+    data_dir = os.path.join(os.path.dirname(__file__), 'data')
+    if not os.path.exists(data_dir):
+        os.makedirs(data_dir)
+    
+    print("✅ Environment setup complete")
+
+def initialize_database():
+    """Initialize the database"""
+    try:
+        init_db()
+        print("✅ Database initialized successfully")
+    except Exception as e:
+        print(f"❌ Database initialization failed: {e}")
+        sys.exit(1)
+
+def check_dependencies():
+    """Check if all required dependencies are installed"""
+    required_packages = [
+        'flask', 'flask_session', 'gtts', 'groq', 'google.generativeai',
+        'requests', 'PIL', 'werkzeug', 'email_validator', 'beautifulsoup4',
+        'feedparser', 'matplotlib', 'plotly', 'pandas', 'numpy'
+    ]
+    
+    missing_packages = []
+    for package in required_packages:
+        try:
+            if package == 'PIL':
+                import PIL
+            elif package == 'google.generativeai':
+                import google.generativeai
+            else:
+                __import__(package)
+        except ImportError:
+            missing_packages.append(package)
+    
+    if missing_packages:
+        print(f"❌ Missing required packages: {', '.join(missing_packages)}")
+        print("Install them with: pip install -r requirements.txt")
+        return False
+    
+    print("✅ All dependencies are installed")
+    return True
+
+def startup_checks():
+    """Perform startup checks"""
+    print("🚀 Starting English Helper...")
+    print("=" * 50)
+    
+    # Check dependencies
+    if not check_dependencies():
+        print("Please install missing dependencies and try again.")
+        sys.exit(1)
+    
+    # Setup environment
+    setup_environment()
+    
+    # Initialize database
+    initialize_database()
+    
+    print("=" * 50)
+    print("✅ All startup checks passed!")
+    print("🌐 Starting Flask application...")
+
+if __name__ == '__main__':
+    startup_checks()
+    
+    # Get configuration from environment
+    debug = os.environ.get('FLASK_DEBUG', 'False').lower() == 'true'
+    port = int(os.environ.get('PORT', 5000))
+    host = os.environ.get('HOST', '127.0.0.1')
+    
+    print(f"📡 Server starting on http://{host}:{port}")
+    print("🎯 Press Ctrl+C to stop the server")
+    
+    # Start the Flask application
+    app.run(
+        host=host,
+        port=port,
+        debug=debug,
+        threaded=True
+    )

study_planner.py

@@ -0,0 +1,460 @@
+# study_planner.py
+import json
+from datetime import datetime, timedelta, date
+from typing import Dict, List, Any
+import logging
+from groq import Groq
+import google.generativeai as genai
+import os
+
+logger = logging.getLogger(__name__)
+
+# Initialize AI clients (reuse from main app)
+groq_client = None
+genai_client = None
+
+try:
+    GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
+    if GROQ_API_KEY:
+        groq_client = Groq(api_key=GROQ_API_KEY)
+except Exception as e:
+    logger.warning(f"Groq client not available: {e}")
+
+try:
+    GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+    if GEMINI_API_KEY:
+        genai.configure(api_key=GEMINI_API_KEY)
+        genai_client = genai
+except Exception as e:
+    logger.warning(f"Gemini client not available: {e}")
+
+class StudyPlanner:
+    def __init__(self):
+        self.level_progression = {
+            'A1': {'next': 'A2', 'weeks': 12, 'focus': ['basic vocabulary', 'present tense', 'introductions']},
+            'A2': {'next': 'B1', 'weeks': 16, 'focus': ['past tense', 'future tense', 'everyday situations']},
+            'B1': {'next': 'B2', 'weeks': 20, 'focus': ['conditional', 'complex sentences', 'opinions']},
+            'B2': {'next': 'C1', 'weeks': 24, 'focus': ['subjunctive', 'formal writing', 'presentations']},
+            'C1': {'next': 'C2', 'weeks': 28, 'focus': ['nuanced expressions', 'academic writing', 'debates']},
+            'C2': {'next': 'C2', 'weeks': 32, 'focus': ['native-like fluency', 'specialized topics', 'literature']}
+        }
+        
+        self.activity_types = {
+            'reading': {
+                'icon': '📚',
+                'min_duration': 20,
+                'max_duration': 45,
+                'difficulty_scaling': True,
+                'description': 'Read articles and texts'
+            },
+            'flashcards': {
+                'icon': '🃏',
+                'min_duration': 10,
+                'max_duration': 25,
+                'difficulty_scaling': False,
+                'description': 'Review vocabulary flashcards'
+            },
+            'conversation': {
+                'icon': '💬',
+                'min_duration': 15,
+                'max_duration': 30,
+                'difficulty_scaling': True,
+                'description': 'Practice speaking and conversation'
+            },
+            'writing': {
+                'icon': '✍️',
+                'min_duration': 15,
+                'max_duration': 40,
+                'difficulty_scaling': True,
+                'description': 'Complete writing exercises'
+            },
+            'listening': {
+                'icon': '🎧',
+                'min_duration': 15,
+                'max_duration': 30,
+                'difficulty_scaling': True,
+                'description': 'Listen to audio content'
+            },
+            'grammar': {
+                'icon': '📝',
+                'min_duration': 10,
+                'max_duration': 25,
+                'difficulty_scaling': True,
+                'description': 'Study grammar rules and patterns'
+            }
+        }
+    
+    def generate_personalized_plan(self, user_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate a comprehensive study plan based on user data"""
+        try:
+            current_level = user_data.get('english_level', 'B1')
+            target_level = user_data.get('target_level', 'B2')
+            weekly_hours = user_data.get('weekly_hours', 5)
+            interests = user_data.get('interests', {})
+            context_focus = user_data.get('context_focus', 'General/Social')
+            study_goals = user_data.get('study_goals', [])
+            
+            # Calculate timeline
+            timeline = self._calculate_study_timeline(current_level, target_level, weekly_hours)
+            
+            # Generate weekly structure
+            weekly_structure = self._create_weekly_structure(weekly_hours, current_level, context_focus)
+            
+            # Create specific activities
+            activities = self._generate_weekly_activities(
+                weekly_structure, interests, current_level, context_focus, study_goals
+            )
+            
+            # Generate AI-powered study tips
+            study_tips = self._generate_ai_study_tips(user_data)
+            
+            plan = {
+                'id': f"plan_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+                'created_at': datetime.now().isoformat(),
+                'current_level': current_level,
+                'target_level': target_level,
+                'weekly_hours': weekly_hours,
+                'estimated_weeks': timeline['weeks'],
+                'completion_date': timeline['completion_date'],
+                'weekly_structure': weekly_structure,
+                'activities': activities,
+                'study_tips': study_tips,
+                'milestones': self._create_milestones(current_level, target_level, timeline['weeks']),
+                'adaptations': self._suggest_adaptations(user_data)
+            }
+            
+            return {'success': True, 'plan': plan}
+            
+        except Exception as e:
+            logger.error(f"Error generating study plan: {e}")
+            return {'success': False, 'error': str(e)}
+    
+    def _calculate_study_timeline(self, current_level: str, target_level: str, weekly_hours: int) -> Dict[str, Any]:
+        """Calculate realistic timeline for reaching target level"""
+        try:
+            current_info = self.level_progression.get(current_level, self.level_progression['B1'])
+            base_weeks = current_info['weeks']
+            
+            # Adjust based on weekly hours (baseline is 5 hours/week)
+            hour_multiplier = 5 / max(weekly_hours, 1)
+            adjusted_weeks = int(base_weeks * hour_multiplier)
+            
+            # If targeting multiple levels ahead, add additional time
+            level_order = ['A1', 'A2', 'B1', 'B2', 'C1', 'C2']
+            current_idx = level_order.index(current_level) if current_level in level_order else 2
+            target_idx = level_order.index(target_level) if target_level in level_order else 3
+            
+            if target_idx > current_idx + 1:
+                # Multiple levels - add 20% more time
+                adjusted_weeks = int(adjusted_weeks * 1.2 * (target_idx - current_idx))
+            
+            completion_date = (datetime.now() + timedelta(weeks=adjusted_weeks)).date()
+            
+            return {
+                'weeks': adjusted_weeks,
+                'completion_date': completion_date.isoformat(),
+                'intensity': 'High' if weekly_hours > 7 else 'Medium' if weekly_hours > 4 else 'Light'
+            }
+            
+        except Exception as e:
+            logger.error(f"Error calculating timeline: {e}")
+            return {'weeks': 16, 'completion_date': (datetime.now() + timedelta(weeks=16)).date().isoformat()}
+    
+    def _create_weekly_structure(self, weekly_hours: int, level: str, context: str) -> Dict[str, Any]:
+        """Create optimal weekly study structure"""
+        try:
+            # Base distribution percentages
+            distributions = {
+                'A1': {'reading': 0.25, 'flashcards': 0.30, 'conversation': 0.20, 'writing': 0.15, 'grammar': 0.10},
+                'A2': {'reading': 0.30, 'flashcards': 0.25, 'conversation': 0.20, 'writing': 0.15, 'grammar': 0.10},
+                'B1': {'reading': 0.30, 'flashcards': 0.20, 'conversation': 0.25, 'writing': 0.20, 'listening': 0.05},
+                'B2': {'reading': 0.25, 'flashcards': 0.15, 'conversation': 0.25, 'writing': 0.25, 'listening': 0.10},
+                'C1': {'reading': 0.30, 'flashcards': 0.10, 'conversation': 0.25, 'writing': 0.25, 'listening': 0.10},
+                'C2': {'reading': 0.35, 'flashcards': 0.05, 'conversation': 0.25, 'writing': 0.25, 'listening': 0.10}
+            }
+            
+            base_dist = distributions.get(level, distributions['B1'])
+            
+            # Adjust based on context
+            if context == 'Professional/Business':
+                base_dist['writing'] = min(base_dist['writing'] + 0.10, 0.40)
+                base_dist['reading'] = max(base_dist['reading'] - 0.05, 0.15)
+                base_dist['conversation'] = max(base_dist['conversation'] - 0.05, 0.15)
+            elif context == 'Technical/IT':
+                base_dist['reading'] = min(base_dist['reading'] + 0.10, 0.45)
+                base_dist['flashcards'] = min(base_dist['flashcards'] + 0.05, 0.35)
+                base_dist['conversation'] = max(base_dist['conversation'] - 0.10, 0.15)
+            
+            # Convert to actual hours
+            weekly_structure = {}
+            total_minutes = weekly_hours * 60
+            
+            for activity, percentage in base_dist.items():
+                minutes = int(total_minutes * percentage)
+                if minutes >= self.activity_types[activity]['min_duration']:
+                    weekly_structure[activity] = {
+                        'minutes_per_week': minutes,
+                        'sessions_per_week': max(1, minutes // 30),  # Aim for 30-min sessions
+                        'minutes_per_session': minutes // max(1, minutes // 30)
+                    }
+            
+            return weekly_structure
+            
+        except Exception as e:
+            logger.error(f"Error creating weekly structure: {e}")
+            return {}
+    
+    def _generate_weekly_activities(self, structure: Dict, interests: Dict, level: str, context: str, goals: List) -> List[Dict]:
+        """Generate specific weekly activities"""
+        activities = []
+        
+        try:
+            for activity_type, schedule in structure.items():
+                activity_info = self.activity_types[activity_type]
+                
+                for session in range(schedule['sessions_per_week']):
+                    activity = {
+                        'id': f"{activity_type}_{session + 1}",
+                        'type': activity_type,
+                        'icon': activity_info['icon'],
+                        'title': f"{activity_info['description']}",
+                        'duration_minutes': schedule['minutes_per_session'],
+                        'difficulty': level,
+                        'context': context,
+                        'day_of_week': (session * 2) % 7,  # Spread throughout week
+                        'specific_tasks': self._generate_specific_tasks(activity_type, level, context, interests, goals)
+                    }
+                    activities.append(activity)
+            
+            # Sort by day of week
+            activities.sort(key=lambda x: x['day_of_week'])
+            
+            return activities
+            
+        except Exception as e:
+            logger.error(f"Error generating activities: {e}")
+            return []
+    
+    def _generate_specific_tasks(self, activity_type: str, level: str, context: str, interests: Dict, goals: List) -> List[str]:
+        """Generate specific tasks for each activity type"""
+        tasks = []
+        
+        try:
+            interest_topics = list(interests.keys())[:3] if interests else ['general topics']
+            
+            if activity_type == 'reading':
+                tasks = [
+                    f"Read a {context.lower()} article about {topic}" for topic in interest_topics
+                ] + [
+                    f"Practice reading comprehension with {level}-level texts",
+                    "Identify new vocabulary and create flashcards"
+                ]
+            
+            elif activity_type == 'flashcards':
+                tasks = [
+                    "Review previous day's vocabulary",
+                    "Practice new words from recent reading",
+                    f"Focus on {context.lower()} terminology"
+                ]
+            
+            elif activity_type == 'conversation':
+                tasks = [
+                    f"Discuss {topic} using {level}-level vocabulary" for topic in interest_topics[:2]
+                ] + [
+                    "Practice pronunciation with AI feedback",
+                    f"Role-play {context.lower()} scenarios"
+                ]
+            
+            elif activity_type == 'writing':
+                tasks = [
+                    f"Write a short text about {topic}" for topic in interest_topics[:1]
+                ] + [
+                    f"Practice {context.lower()} writing format s",
+                    "Get AI feedback on grammar and style"
+                ]
+            
+            elif activity_type == 'listening':
+                tasks = [
+                    f"Listen to content about {topic}" for topic in interest_topics[:2]
+                ] + [
+                    "Practice with different accents",
+                    "Take notes while listening"
+                ]
+            
+            elif activity_type == 'grammar':
+                level_grammar = {
+                    'A1': ['present tense', 'basic sentence structure', 'personal pronouns'],
+                    'A2': ['past tense', 'future tense', 'comparatives'],
+                    'B1': ['present perfect', 'conditional sentences', 'passive voice'],
+                    'B2': ['subjunctive mood', 'complex sentences', 'reported speech'],
+                    'C1': ['advanced tenses', 'nuanced expressions', 'formal structures'],
+                    'C2': ['idiomatic expressions', 'stylistic variations', 'literary devices']
+                }
+                
+                tasks = [f"Study {topic}" for topic in level_grammar.get(level, level_grammar['B1'])]
+            
+            return tasks[:3]  # Limit to 3 tasks per activity
+            
+        except Exception as e:
+            logger.error(f"Error generating specific tasks: {e}")
+            return ["Complete activity as planned"]
+    
+    def _generate_ai_study_tips(self, user_data: Dict) -> List[str]:
+        """Generate personalized study tips using AI"""
+        try:
+            if not groq_client and not genai_client:
+                return self._get_default_tips(user_data.get('english_level', 'B1'))
+            
+            prompt = f"""
+            Generate 5 personalized English study tips for a user with these characteristics:
+            - Current Level: {user_data.get('english_level', 'B1')}
+            - Target Level: {user_data.get('target_level', 'B2')}
+            - Weekly Study Time: {user_data.get('weekly_hours', 5)} hours
+            - Context Focus: {user_data.get('context_focus', 'General/Social')}
+            - Interests: {', '.join(user_data.get('interests', {}).keys())}
+            
+            Provide practical, actionable tips that are specific to their level and interests.
+            Format as a simple list of tips, each starting with an emoji.
+            """
+            
+            response_text = None
+            if groq_client:
+                response = groq_client.chat.completions.create(
+                    model="llama-3.1-8b-instant",
+                    messages=[{"role": "user", "content": prompt}],
+                    temperature=0.7
+                )
+                response_text = response.choices[0].message.content
+            elif genai_client:
+                model = genai_client.GenerativeModel('gemini-2.5-flash-latest')
+                response = model.generate_content(prompt)
+                response_text = response.text
+            
+            if response_text:
+                # Extract tips from response
+                tips = [line.strip() for line in response_text.split('\n') if line.strip() and ('📚' in line or '💡' in line or '🎯' in line or '⭐' in line or '🚀' in line)]
+                return tips[:5] if tips else self._get_default_tips(user_data.get('english_level', 'B1'))
+            
+            return self._get_default_tips(user_data.get('english_level', 'B1'))
+            
+        except Exception as e:
+            logger.error(f"Error generating AI study tips: {e}")
+            return self._get_default_tips(user_data.get('english_level', 'B1'))
+    
+    def _get_default_tips(self, level: str) -> List[str]:
+        """Get default study tips based on level"""
+        tips_by_level = {
+            'A1': [
+                "📚 Start with basic vocabulary - 10 new words daily",
+                "🎯 Focus on present tense in daily conversations",
+                "💡 Use picture dictionaries for visual learning",
+                "⭐ Practice pronunciation with simple audio materials",
+                "🚀 Don't worry about mistakes - communication is key!"
+            ],
+            'A2': [
+                "📚 Read simple news articles and stories",
+                "🎯 Practice past and future tenses regularly",
+                "💡 Join basic English conversation groups",
+                "⭐ Use language learning apps for daily practice",
+                "🚀 Watch movies with subtitles in your language"
+            ],
+            'B1': [
+                "📚 Read intermediate articles on topics you enjoy",
+                "🎯 Practice expressing opinions and preferences",
+                "💡 Start writing short paragraphs daily",
+                "⭐ Listen to podcasts at normal speed",
+                "🚀 Try to think in English for simple tasks"
+            ],
+            'B2': [
+                "📚 Read longer articles and opinion pieces",
+                "🎯 Practice formal and informal writing styles",
+                "💡 Engage in debates and discussions",
+                "⭐ Watch news programs without subtitles",
+                "🚀 Set specific goals for each study session"
+            ],
+            'C1': [
+                "📚 Read academic and professional texts",
+                "🎯 Practice nuanced expressions and idioms",
+                "💡 Write formal reports and presentations",
+                "⭐ Listen to academic lectures and conferences",
+                "🚀 Focus on specialized vocabulary for your field"
+            ],
+            'C2': [
+                "📚 Read literature and complex analytical texts",
+                "🎯 Master subtle language differences",
+                "💡 Write with stylistic sophistication",
+                "⭐ Engage with native speakers in professional contexts",
+                "🚀 Aim for native-like fluency in all skills"
+            ]
+        }
+        
+        return tips_by_level.get(level, tips_by_level['B1'])
+    
+    def _create_milestones(self, current_level: str, target_level: str, weeks: int) -> List[Dict]:
+        """Create progress milestones"""
+        milestones = []
+        
+        try:
+            milestone_intervals = max(2, weeks // 4)  # Create 4 milestones
+            
+            for i in range(1, 5):
+                week = milestone_intervals * i
+                if week <= weeks:
+                    milestone = {
+                        'week': week,
+                        'title': f"Milestone {i}",
+                        'description': self._get_milestone_description(i, current_level, target_level),
+                        'target_date': (datetime.now() + timedelta(weeks=week)).date().isoformat(),
+                        'completed': False
+                    }
+                    milestones.append(milestone)
+            
+            return milestones
+            
+        except Exception as e:
+            logger.error(f"Error creating milestones: {e}")
+            return []
+    
+    def _get_milestone_description(self, milestone_num: int, current_level: str, target_level: str) -> str:
+        """Get description for milestone"""
+        descriptions = {
+            1: f"Complete foundation review and establish study routine",
+            2: f"Reach intermediate proficiency between {current_level} and {target_level}",
+            3: f"Demonstrate advanced skills approaching {target_level} level",
+            4: f"Achieve {target_level} level proficiency in all skills"
+        }
+        
+        return descriptions.get(milestone_num, f"Progress checkpoint {milestone_num}")
+    
+    def _suggest_adaptations(self, user_data: Dict) -> List[str]:
+        """Suggest plan adaptations based on user data"""
+        adaptations = []
+        
+        try:
+            weekly_hours = user_data.get('weekly_hours', 5)
+            context = user_data.get('context_focus', 'General/Social')
+            level = user_data.get('english_level', 'B1')
+            
+            if weekly_hours < 4:
+                adaptations.append("💡 Consider increasing study time to 4+ hours/week for faster progress")
+            
+            if weekly_hours > 8:
+                adaptations.append("⚠️ Ensure you don't burn out - quality over quantity")
+            
+            if context == 'Professional/Business':
+                adaptations.append("📊 Focus extra time on business writing and presentation skills")
+            
+            if context == 'Technical/IT':
+                adaptations.append("💻 Include technical documentation reading in your routine")
+            
+            if level in ['C1', 'C2']:
+                adaptations.append("🎯 Consider specialized courses or certification preparation")
+            
+            return adaptations[:3]  # Limit to 3 adaptations
+            
+        except Exception as e:
+            logger.error(f"Error suggesting adaptations: {e}")
+            return []
+
+# Global instance
+study_planner = StudyPlanner()