Upload 6 files

admin_module.py

@@ -0,0 +1,562 @@
+# 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"""
+        authenticated = session.get('admin_authenticated', False)
+        username = session.get('admin_username')
+        login_time = session.get('admin_login_time')
+        
+        # Debug logging
+        logger.info(f"Admin auth check: authenticated={authenticated}, username={username}, login_time={login_time}")
+        
+        # Check if session has expired (24 hours)
+        if authenticated and login_time:
+            try:
+                login_datetime = datetime.fromisoformat(login_time)
+                if datetime.now() - login_datetime > timedelta(hours=24):
+                    logger.info("Admin session expired, logging out")
+                    self.logout_admin()
+                    return False
+            except Exception as e:
+                logger.error(f"Error checking session expiry: {e}")
+                
+        return authenticated
+    
+    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()
+            session.permanent = True  # Make session permanent
+            
+            logger.info(f"Admin login successful: {username}")
+            return True
+        else:
+            logger.warning(f"Admin login failed for username: {username}")
+            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):
+        is_authenticated = admin_manager.is_admin_logged_in()
+        
+        # Enhanced logging for debugging
+        from flask import session, request
+        logger.info(f"Admin required check for {f.__name__}: authenticated={is_authenticated}")
+        logger.info(f"Session keys: {list(session.keys())}")
+        logger.info(f"Request URL: {request.url}")
+        
+        if not is_authenticated:
+            logger.warning(f"Admin authentication failed for {f.__name__}")
+            return jsonify({
+                'error': 'Admin authentication required',
+                'authenticated': False,
+                'endpoint': f.__name__
+            }), 401
+        
+        logger.info(f"Admin access granted to {f.__name__}")
+        return f(*args, **kwargs)
+    return decorated_function
+
+# Global admin manager instance
+admin_manager = AdminManager()

app.py

@@ -1,21 +1,20 @@
 #!/usr/bin/env python3
 """
-English Helper - HF Spaces Version (Simplified)
-Sistema de aprendizado de inglês sem autenticação para máxima compatibilidade
+English Helper - Hugging Face Spaces
+Sistema completo de aprendizado de inglês com IA
 """
 
 import os
-import json
-from datetime import datetime
+import threading
+import time
 
-def init_simple_storage():
-    """Inicializar armazenamento simples baseado em arquivos"""
+def init_system():
+    """Inicializar sistema completo"""
     try:
-        os.makedirs('hf_data', exist_ok=True)
-        os.makedirs('hf_data/flashcards', exist_ok=True)
-        os.makedirs('hf_data/conversations', exist_ok=True)
-        os.makedirs('hf_data/analytics', exist_ok=True)
-        print("✅ Sistema de armazenamento HF inicializado")
+        os.environ.setdefault('FLASK_ENV', 'production')
+        from database import init_db
+        init_db()
+        print("✅ Banco de dados inicializado")
         return True
     except Exception as e:
         print(f"❌ Erro na inicialização: {e}")
@@ -23,18 +22,19 @@ def init_simple_storage():
 
 # Executar aplicação
 if __name__ == "__main__":
-    print("🎯 English Helper HF - Versão Simplificada")
+    print("🎯 English Helper - Iniciando...")
     
     # Inicializar sistema
-    if not init_simple_storage():
+    if not init_system():
         print("❌ Falha na inicialização")
         exit(1)
     
     try:
-        # Importar Flask app simplificado
-        import flask_app_hf
-        app = flask_app_hf.app
+        # Importar Flask app
+        import flask_app
+        app = flask_app.app
         
+        # Executar na porta correta para HF Spaces
         print("🚀 Executando Flask na porta 7860 (HF Spaces)")
         app.run(
             host="0.0.0.0",
@@ -47,4 +47,4 @@ if __name__ == "__main__":
     except Exception as e:
         print(f"❌ Erro: {e}")
         import traceback
-        traceback.print_exc()
+        traceback.print_exc()

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,785 @@
+# 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 get_db_connection():
+    """Get a new database connection (for use outside Flask context)"""
+    conn = sqlite3.connect(DATABASE_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+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()
+        
+        # For HF Spaces demo mode, auto-confirm emails
+        is_hf_spaces = os.environ.get('SPACE_ID') is not None
+        has_smtp_username = os.environ.get('SMTP_USERNAME') is not None
+        has_smtp_password = os.environ.get('SMTP_PASSWORD') is not None
+        has_smtp = has_smtp_username and has_smtp_password
+        
+        # Sempre auto-confirmar no HF Spaces ou quando SMTP não está configurado
+        auto_confirm = is_hf_spaces or not has_smtp
+        
+        # Debug logging
+        logger.info(f"Registration debug - SPACE_ID: {os.environ.get('SPACE_ID')}")
+        logger.info(f"HF_Spaces: {is_hf_spaces}, SMTP_USER: {has_smtp_username}, SMTP_PASS: {has_smtp_password}")
+        logger.info(f"SMTP configured: {has_smtp}, Auto-confirm: {auto_confirm}")
+        
+        # Insert user
+        cursor = db.execute(
+            '''INSERT INTO users (email, password_hash, salt, confirmation_token, is_confirmed) 
+               VALUES (?, ?, ?, ?, ?)''',
+            (email, password_hash, salt, confirmation_token, auto_confirm)
+        )
+        user_id = cursor.lastrowid
+        
+        # Create default user settings
+        db.execute(
+            '''INSERT INTO user_settings (user_id) VALUES (?)''',
+            (user_id,)
+        )
+        
+        db.commit()
+        
+        if auto_confirm:
+            logger.info(f"User created and auto-confirmed: {email} (HF Spaces demo mode)")
+            message = 'Account created and ready to use! (Demo mode - no email confirmation needed)'
+        else:
+            logger.info(f"User created: {email}")
+            message = 'User created successfully. Please check your email for confirmation.'
+            
+        return {
+            'success': True, 
+            'user_id': user_id,
+            'confirmation_token': confirmation_token,
+            'message': message,
+            'auto_confirmed': auto_confirm
+        }
+        
+    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 with timeout)"""
+    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 - skipping email")
+            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 with timeout
+        import socket
+        
+        # Set socket timeout to prevent hanging
+        socket.setdefaulttimeout(10)
+        
+        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()
+        
+        # Reset socket timeout
+        socket.setdefaulttimeout(None)
+        
+        logger.info(f"Confirmation email sent to {email}")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Error sending confirmation email: {e}")
+        # Reset socket timeout on error
+        try:
+            import socket
+            socket.setdefaulttimeout(None)
+        except:
+            pass
+        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 []

flask_app.py

@@ -0,0 +1,1356 @@
+# flask_app.py - English Helper Flask Application
+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  # Removido para usar sessões nativas do Flask
+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 ---
+# Evitar múltiplas instâncias do Flask
+if 'app' not in globals():
+    app = Flask(__name__)
+    
+    # Configuration for sessions - Simplificado para HF Spaces
+    app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', 'dev-key-change-in-production-hf-spaces')
+    app.config['PERMANENT_SESSION_LIFETIME'] = 86400  # 24 hours
+    
+    # Configurações específicas para HF Spaces
+    app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
+    app.config['TEMPLATES_AUTO_RELOAD'] = True
+    app.config['SESSION_COOKIE_SECURE'] = False  # HF Spaces pode ter problemas com HTTPS interno
+    app.config['SESSION_COOKIE_HTTPONLY'] = True
+    app.config['SESSION_COOKIE_SAMESITE'] = 'Lax'  # Mais permissivo para HF Spaces
+    app.config['SESSION_COOKIE_NAME'] = 'englishhelper_session'
+    
+    # Usar sessões nativas do Flask ao invés de Flask-Session
+    # Session(app)  # Comentado para usar sessões nativas
+    
+    # Print session config for debugging
+    print(f"✅ Flask app inicializado - SECRET_KEY length: {len(app.config['SECRET_KEY'])}")
+    print(f"✅ Session config - Usando sessões nativas do Flask")
+    print(f"✅ Working directory: {os.getcwd()}")
+else:
+    print("✅ Flask app já existe - reutilizando instância")
+
+# Adicionar middleware para debug de sessão
+@app.before_request
+def debug_session():
+    if request.endpoint and 'admin' in request.endpoint:
+        print(f"🔍 Session Debug - Endpoint: {request.endpoint}")
+        print(f"🔍 Session Data: {dict(session)}")
+        print(f"🔍 All Cookies: {dict(request.cookies)}")
+        print(f"🔍 Session ID: {request.cookies.get('englishhelper_session', 'no-session')}")
+        print(f"🔍 User Agent: {request.headers.get('User-Agent', 'unknown')[:50]}...")
+
+@app.after_request
+def ensure_session_saved(response):
+    """Garantir que a sessão seja salva"""
+    try:
+        if hasattr(session, 'accessed') and session.accessed:
+            session.permanent = True
+    except Exception as e:
+        print(f"Session save error: {e}")
+    return response
+
+# Database initialization (handled by app.py)
+def initialize_database():
+    init_db()
+
+# Note: Database initialization moved to app.py to avoid conflicts
+
+# 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 ---
+
+# Cache de áudio TTS em memória
+tts_cache = {}
+
+@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
+    
+    # Validar comprimento do texto (10000 caracteres max)
+    if len(text) > 10000:
+        return jsonify({"error": "Text is too long. Maximum 10,000 characters allowed."}), 400
+    
+    # Criar chave de cache baseada no texto e TLD
+    import hashlib
+    cache_key = hashlib.md5(f"{text}_{tld}".encode()).hexdigest()
+    
+    try:
+        # Verificar se está no cache
+        if cache_key in tts_cache:
+            print(f"🎵 TTS Cache HIT: {len(text)} chars")
+            cached_audio = tts_cache[cache_key]
+            audio_fp = io.BytesIO(cached_audio)
+            return send_file(audio_fp, mimetype='audio/mpeg', as_attachment=False)
+        
+        # Gerar novo áudio
+        print(f"🎵 TTS Cache MISS: Gerando áudio para {len(text)} chars, tld: {tld}")
+        
+        tts = gTTS(text=text, lang='en', tld=tld)
+        mp3_fp = io.BytesIO()
+        tts.write_to_fp(mp3_fp)
+        mp3_fp.seek(0)
+        
+        # Salvar no cache
+        audio_data = mp3_fp.read()
+        tts_cache[cache_key] = audio_data
+        
+        # Limitar cache a 50 entradas
+        if len(tts_cache) > 50:
+            oldest_key = next(iter(tts_cache))
+            del tts_cache[oldest_key]
+            
+        # Retornar áudio
+        audio_fp = io.BytesIO(audio_data)
+        return send_file(audio_fp, mimetype='audio/mpeg', as_attachment=False)
+        
+    except Exception as e:
+        print(f"❌ TTS Error: {e}")
+        return jsonify({"error": f"Failed to generate audio via gTTS: {e}"}), 500
+
+# Primeira função explain_proxy removida - duplicata
+
+@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']:
+            # Try to send confirmation email (non-blocking for HF Spaces)
+            email_sent = False
+            try:
+                # Use a timeout to prevent hanging
+                import threading
+                import time
+                
+                def send_email_async():
+                    nonlocal email_sent
+                    try:
+                        email_sent = send_confirmation_email(email, result['confirmation_token'])
+                    except:
+                        email_sent = False
+                
+                # Start email sending in background with timeout
+                email_thread = threading.Thread(target=send_email_async)
+                email_thread.daemon = True
+                email_thread.start()
+                email_thread.join(timeout=5)  # 5 second timeout
+                
+            except Exception as e:
+                print(f"Email sending timeout or error: {e}")
+                email_sent = False
+            
+            # Return success message based on auto-confirmation and email status
+            auto_confirmed = result.get('auto_confirmed', False)
+            
+            if auto_confirmed:
+                return jsonify({
+                    'message': 'Registration successful! Your account is ready to use - you can log in immediately.',
+                    'email_sent': email_sent,
+                    'auto_confirmed': True,
+                    'note': 'Email confirmation is disabled in demo mode.'
+                }), 201
+            elif email_sent:
+                return jsonify({
+                    'message': 'Registration successful! Please check your email to confirm your account.',
+                    'email_sent': True,
+                    'auto_confirmed': False
+                }), 201
+            else:
+                return jsonify({
+                    'message': 'Registration successful! However, we could not send the confirmation email. Please contact support.',
+                    'email_sent': False,
+                    'auto_confirmed': 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')
+        
+        print(f"Admin login attempt - Username: {username}")
+        
+        if admin_manager.login_admin(username, password):
+            print(f"Admin login successful - Session ID: {session.get('_id', 'no-id')}")
+            print(f"Session data after login: {dict(session)}")
+            return jsonify({'success': True, 'message': 'Admin logged in successfully'})
+        else:
+            print(f"Admin login failed - Invalid credentials for: {username}")
+            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()
+        username = session.get('admin_username')
+        
+        print(f"Admin check - Authenticated: {is_authenticated}, Username: {username}")
+        print(f"Current session data: {dict(session)}")
+        print(f"Session ID: {session.get('_id', 'no-session-id')}")
+        
+        return jsonify({
+            'authenticated': is_authenticated,
+            'username': username if is_authenticated else None,
+            'session_id': session.get('_id', 'no-session-id'),
+            'debug_session_keys': list(session.keys())
+        })
+    except Exception as e:
+        print(f"Admin check error: {e}")
+        return jsonify({'authenticated': False})
+
+# Debug route to test sessions
+@app.route('/admin/debug-session', methods=['GET', 'POST'])
+def debug_session():
+    """Debug session functionality"""
+    if request.method == 'POST':
+        session['debug_test'] = 'session_working'
+        session.permanent = True
+        return jsonify({
+            'message': 'Session test value set',
+            'session_data': dict(session)
+        })
+    else:
+        test_value = session.get('debug_test', 'not_found')
+        return jsonify({
+            'test_value': test_value,
+            'session_data': dict(session),
+            'session_id': session.get('_id', 'no-session-id')
+        })
+
+@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('templates/admin.html')
+
+@app.route('/')
+def root():
+    return send_file('templates/index.html')
+
+# Evitar execução automática quando importado
+if __name__ == '__main__':
+    print("⚠️  flask_app.py executado diretamente")
+    print("💡 Use app.py para HF Spaces ou execute como módulo")
+    app.run(host='0.0.0.0', port=5000, debug=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()