# 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 []