Delete flask_app.py

flask_app.py

@@ -1,1356 +0,0 @@
-# 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)