Update app.py

app.py

@@ -1,57 +1,392 @@
 import streamlit as st
-import google.generativeai as genai
+import pandas as pd
 import json
-import re
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import google.generativeai as genai
 import os
+import re
+import math
+import time
+
+# ============================================
+# 🚀 CONFIGURATION FOR HUGGING FACE DEPLOYMENT
+# ============================================
+
+# Page configuration
+st.set_page_config(
+    page_title="AI Study Planner Pro",
+    page_icon="📚",
+    layout="wide",
+    initial_sidebar_state="collapsed"
+)
+
+# Get API Key from Hugging Face Secrets
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "")
+
+# ============================================
+# 🎨 CUSTOM CSS WITH IMPROVED STYLING
+# ============================================
+
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        color: #1E3A8A;
+        text-align: center;
+        margin-bottom: 1rem;
+        font-weight: 800;
+    }
+    
+    .tagline {
+        font-size: 1.2rem;
+        color: #6B7280;
+        text-align: center;
+        margin-bottom: 2rem;
+        font-weight: 400;
+    }
+    
+    .sub-header {
+        font-size: 1.8rem;
+        color: #3B82F6;
+        margin-top: 1.5rem;
+        margin-bottom: 1rem;
+        font-weight: 700;
+        border-bottom: 3px solid #3B82F6;
+        padding-bottom: 10px;
+    }
+    
+    .metric-card {
+        background-color: #F3F4F6;
+        padding: 1rem;
+        border-radius: 10px;
+        border-left: 5px solid #3B82F6;
+        margin-bottom: 1rem;
+    }
+    
+    .debug-box {
+        background-color: #FEF3C7;
+        border: 2px solid #F59E0B;
+        padding: 1.5rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+        font-family: monospace;
+        font-size: 0.9rem;
+    }
+    
+    .raw-response-box {
+        background-color: #1F2937;
+        color: #D1D5DB;
+        padding: 1rem;
+        border-radius: 5px;
+        font-family: 'Courier New', monospace;
+        font-size: 0.8rem;
+        max-height: 400px;
+        overflow-y: auto;
+        white-space: pre-wrap;
+        word-wrap: break-word;
+    }
+    
+    .success-box {
+        background-color: #D1FAE5;
+        border: 2px solid #10B981;
+        padding: 1rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+    }
+    
+    .error-box {
+        background-color: #FEE2E2;
+        border: 2px solid #EF4444;
+        padding: 1rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+    }
+    
+    .info-box {
+        background-color: #DBEAFE;
+        border: 2px solid #3B82F6;
+        padding: 1rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# ============================================
+# 🔧 SESSION STATE INITIALIZATION - UPDATED
+# ============================================
 
-# Set your API key
-os.environ["GEMINI_API_KEY"] = "your-api-key-here"  # Replace with your actual key
+def init_session_state():
+    """Initialize all session state variables"""
+    session_vars = {
+        'study_plan': None,
+        'progress': {},
+        'subject': "",
+        'api_key': GEMINI_API_KEY,
+        'raw_ai_response': "",  # NEW: Store raw AI response
+        'ai_response_debug': False,  # NEW: Debug mode toggle
+        'show_debug': False,
+        'goal_type': "Skill/Topic Completion",
+        'target_date': None,
+        'study_days': ["Mon", "Tue", "Wed", "Thu", "Fri"],
+        'plan_loaded': False,
+        'current_week': 1,
+        'task_states': {},
+        'weekly_streak': 0,
+        'longest_weekly_streak': 0,
+        'selected_topics': [],
+        'ai_error_message': "",
+        'plan_generation_attempted': False,
+        'api_available': True,
+        'api_quota_exceeded': False,
+        'last_raw_response': ""  # NEW: Store last response for debugging
+    }
+    
+    for key, value in session_vars.items():
+        if key not in st.session_state:
+            st.session_state[key] = value
+
+init_session_state()
+
+# ============================================
+# 🛠️ UTILITY FUNCTIONS
+# ============================================
+
+def calculate_learning_quality(days_available, hours_per_day, study_days_count):
+    """Calculate learning quality score"""
+    total_study_hours = days_available * hours_per_day
+    required_hours = 60
+    coverage = min(100, (total_study_hours / required_hours) * 100)
+    
+    quality_score = 0
+    
+    if 1 <= hours_per_day <= 3:
+        quality_score += 30
+    elif hours_per_day > 3:
+        quality_score += 20
+    else:
+        quality_score += 10
+    
+    if 3 <= study_days_count <= 5:
+        quality_score += 30
+    elif study_days_count > 5:
+        quality_score += 20
+    else:
+        quality_score += 10
+    
+    if coverage >= 80:
+        quality_score += 40
+    elif coverage >= 50:
+        quality_score += 20
+    else:
+        quality_score += 10
+    
+    return {
+        "quality_score": min(100, quality_score),
+        "coverage_percentage": coverage,
+        "total_hours": total_study_hours,
+        "required_hours": required_hours,
+        "weekly_hours": hours_per_day * study_days_count,
+        "is_optimal": quality_score >= 60,
+        "is_severely_inadequate": (study_days_count < 2 and days_available < 30) or (coverage < 30)
+    }
 
-def test_ai_response(subject, topics=[], days_available=60, hours_per_day=2, study_days=["Mon", "Tue", "Wed", "Thu", "Fri"], current_level="Beginner"):
-    """Test what the AI model actually returns"""
+def sanitize_study_inputs(subject, goal):
+    """Enhanced sanitization for safe AI interaction"""
+    if not subject:
+        return subject, goal
+    
+    clean_subject = subject.lower().strip()
+    clean_goal = goal.lower().strip() if goal else ""
+    
+    educational_replacements = {
+        'hack': 'cybersecurity analysis',
+        'hacking': 'cybersecurity studies',
+        'exploit': 'security analysis',
+        'crack': 'security testing',
+        'bypass': 'security assessment',
+        'attack': 'defensive strategy',
+    }
+    
+    for risky, safe in educational_replacements.items():
+        if risky in clean_subject:
+            clean_subject = clean_subject.replace(risky, safe)
+        if risky in clean_goal:
+            clean_goal = clean_goal.replace(risky, safe)
+    
+    if clean_goal and not any(x in clean_goal for x in ['learn', 'study', 'understand', 'master', 'explore', 'analyze']):
+        clean_goal += " learning"
+    
+    clean_subject = clean_subject.title()
+    clean_goal = clean_goal.capitalize()
+    
+    return clean_subject, clean_goal
+
+# ============================================
+# 🤖 AI RESPONSE DEBUGGER - INTEGRATED
+# ============================================
+
+def show_ai_response_debug(raw_response, parsed_json=None, error=None):
+    """Display AI response debugging information"""
+    
+    st.markdown('<div class="debug-box">', unsafe_allow_html=True)
+    st.markdown("### 🐛 AI Response Debug")
+    
+    # Basic info
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        st.metric("Length", f"{len(raw_response)} chars")
+    with col2:
+        has_markdown = "```" in raw_response
+        st.metric("Markdown", "✅" if has_markdown else "❌")
+    with col3:
+        has_explanation = any(x in raw_response.lower() for x in ['here is', "here's", 'the study plan'])
+        st.metric("Explanation", "✅" if has_explanation else "❌")
+    with col4:
+        is_pure_json = raw_response.strip().startswith('{') and raw_response.strip().endswith('}')
+        st.metric("Pure JSON", "✅" if is_pure_json else "❌")
+    
+    # Show raw response
+    with st.expander("📥 View Raw AI Response", expanded=True):
+        st.markdown('<div class="raw-response-box">', unsafe_allow_html=True)
+        st.text(raw_response)
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Show first and last parts
+    col_left, col_right = st.columns(2)
+    with col_left:
+        st.text("First 500 characters:")
+        st.code(raw_response[:500], language="text")
+    with col_right:
+        st.text("Last 500 characters:")
+        st.code(raw_response[-500:] if len(raw_response) > 500 else raw_response, language="text")
+    
+    # Show analysis
+    if error:
+        st.markdown('<div class="error-box">', unsafe_allow_html=True)
+        st.error(f"❌ JSON Parsing Error: {error}")
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    if parsed_json:
+        st.markdown('<div class="success-box">', unsafe_allow_html=True)
+        st.success("✅ JSON Parsed Successfully!")
+        with st.expander("View Parsed JSON"):
+            st.json(parsed_json)
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Copy to clipboard button
+    if st.button("📋 Copy Raw Response to Clipboard"):
+        st.code(raw_response, language="text")
+        st.success("Response copied! Paste it in our chat for analysis.")
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+    return raw_response
+
+def extract_json_robust(text):
+    """Robust JSON extraction with debugging"""
+    if not text:
+        return None
+    
+    st.session_state.last_raw_response = text
+    
+    # Method 1: Try direct parse
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        pass
+    
+    # Method 2: Remove markdown
+    cleaned = text.replace("```json", "").replace("```", "").strip()
+    try:
+        return json.loads(cleaned)
+    except json.JSONDecodeError:
+        pass
+    
+    # Method 3: Extract between { and }
+    start = text.find('{')
+    end = text.rfind('}') + 1
+    
+    if start != -1 and end != -1:
+        extracted = text[start:end]
+        # Clean extracted JSON
+        extracted = re.sub(r'//.*', '', extracted)  # Remove comments
+        extracted = re.sub(r',\s*}', '}', extracted)  # Remove trailing commas
+        extracted = re.sub(r',\s*]', ']', extracted)
+        extracted = extracted.replace('"', '"').replace('"', '"')  # Fix smart quotes
+        
+        try:
+            return json.loads(extracted)
+        except json.JSONDecodeError:
+            pass
+    
+    # Method 4: Try to fix common issues
+    try:
+        # Replace single quotes with double quotes for keys
+        fixed = re.sub(r"(\w+):", r'"\1":', text)
+        fixed = re.sub(r"'", '"', fixed)
+        return json.loads(fixed)
+    except json.JSONDecodeError:
+        pass
+    
+    return None
+
+# ============================================
+# 🤖 AI STUDY PLAN GENERATION WITH DEBUG
+# ============================================
+
+def generate_study_plan_with_debug(api_key, **kwargs):
+    """Generate study plan with integrated debugging"""
     
-    api_key = os.environ.get("GEMINI_API_KEY")
     if not api_key:
-        st.error("❌ Please set GEMINI_API_KEY environment variable")
+        st.session_state.ai_error_message = "API key missing"
         return None
     
     try:
         # Configure API
         genai.configure(api_key=api_key)
-        model = genai.GenerativeModel('gemini-2.5-flash')  # Or gemini-1.5-flash
-        
-        # Sanitize subject
-        subject_clean = subject.lower().strip()
-        subject_clean = subject_clean.title()
+        model = genai.GenerativeModel('gemini-2.5-flash')
         
-        # Calculate weeks
-        weeks = max(1, days_available // 7)
+        # Extract parameters
+        original_subject = kwargs.get('subject', 'General Learning')
+        original_goal = kwargs.get('goal', '')
+        selected_topics = kwargs.get('selected_topics', [])
+        days_available = kwargs.get('days_available', 60)
+        hours_per_day = kwargs.get('hours_per_day', 2)
+        study_days = kwargs.get('study_days', ["Mon", "Tue", "Wed", "Thu", "Fri"])
         study_days_count = len(study_days)
+        weeks = max(1, days_available // 7)
+        
+        # Sanitize inputs
+        safe_subject, safe_goal = sanitize_study_inputs(original_subject, original_goal)
         
         # Topics text
         topics_text = ""
-        if topics:
-            topics_text = f"SPECIFIC TOPICS TO COVER: {', '.join(topics)}"
+        if selected_topics:
+            topics_text = f"SPECIFIC TOPICS TO COVER: {', '.join(selected_topics)}"
         
-        # Your exact prompt
-        prompt = f"""Create a comprehensive, practical study plan for learning: {subject_clean}
+        # STRICT PROMPT with explicit instructions
+        prompt = f'''You are a JSON generator. Return ONLY valid JSON, nothing else.
 
+Create a study plan for: {safe_subject}
 {topics_text}
-LEARNING GOAL: Master {subject_clean}
+LEARNING GOAL: {safe_goal or "Master " + safe_subject}
 DURATION: {weeks} weeks ({days_available} days)
-STUDY SCHEDULE: {hours_per_day} hours/day, {study_days_count} days/week ({', '.join(study_days)})
-CURRENT LEVEL: {current_level}
+STUDY SCHEDULE: {hours_per_day} hours/day, {study_days_count} days/week ({", ".join(study_days)})
+CURRENT LEVEL: {kwargs.get('current_level', 'Beginner')}
 
-IMPORTANT RULES:
-1. Return ONLY valid JSON format
-2. NO markdown, NO explanations, NO comments
-3. NO emojis in the JSON
-4. NO trailing commas
-5. Ensure proper JSON syntax
+CRITICAL INSTRUCTIONS:
+1. Return ONLY a valid JSON object
+2. NO markdown code blocks, NO explanations
+3. NO comments in the JSON
+4. NO emojis
+5. NO trailing commas
+6. Use double quotes for all strings
 
 REQUIRED JSON STRUCTURE:
 {{
-  "subject": "{subject_clean}",
+  "subject": "{safe_subject}",
   "total_weeks": {weeks},
   "daily_hours": {hours_per_day},
   "study_days": {json.dumps(study_days)},
@@ -64,7 +399,7 @@ REQUIRED JSON STRUCTURE:
   "weekly_schedule": [
     {{
       "week": 1,
-      "focus": "Week 1: Introduction to {subject_clean}",
+      "focus": "Week 1: Introduction to {safe_subject}",
       "objectives": ["Understand basic concepts", "Setup learning environment", "Complete first exercises"],
       "daily_tasks": [
         ["Read introduction chapter", "Watch tutorial video"],
@@ -74,183 +409,512 @@ REQUIRED JSON STRUCTURE:
         ["Weekly review", "Plan next week"]
       ],
       "day_focus": ["Introduction", "Practice", "Review", "Application", "Planning"],
-      "week_summary": "This week focuses on building foundational knowledge of {subject_clean}.",
+      "week_summary": "This week focuses on building foundational knowledge.",
       "resources": ["Online tutorials", "Practice exercises", "Reference materials"],
-      "milestone": "Complete basic understanding of {subject_clean}"
+      "milestone": "Complete basic understanding"
     }}
   ],
   "study_tips": ["Study regularly", "Practice daily", "Review weekly", "Ask questions when stuck"],
   "success_metrics": ["Complete all weekly tasks", "Understand core concepts", "Apply knowledge practically"]
 }}
 
-For each week in weekly_schedule:
-- Create {weeks} weeks total
-- Each week must have 5 days of daily_tasks (2-3 tasks per day)
-- Make tasks specific and actionable
-- Include real learning objectives
-- Cover topics: {', '.join(topics) if topics else 'all essential topics'}
+Add weeks 2 through {weeks} with similar structure.
 
-Return ONLY the JSON object, nothing else."""
+IMPORTANT: Start your response with {{ and end with }}. Return ONLY JSON.'''
 
-        st.markdown("### 📤 Sending this prompt to AI:")
-        st.code(prompt[:1000] + "..." if len(prompt) > 1000 else prompt, language="text")
+        # Store prompt for debugging
+        st.session_state.last_prompt = prompt
         
         # Generate response
-        with st.spinner("🤖 Asking AI..."):
-            response = model.generate_content(
-                prompt,
-                generation_config=genai.GenerationConfig(
-                    max_output_tokens=4000,
-                    temperature=0.7
-                )
-            )
+        response = model.generate_content(
+            prompt,
+            generation_config=genai.GenerationConfig(
+                max_output_tokens=4000,
+                temperature=0.3,  # Lower temperature for consistent JSON
+                top_p=0.8
+            ),
+            safety_settings={
+                'HARM_CATEGORY_HARASSMENT': 'BLOCK_MEDIUM_AND_ABOVE',
+                'HARM_CATEGORY_HATE_SPEECH': 'BLOCK_MEDIUM_AND_ABOVE',
+                'HARM_CATEGORY_SEXUALLY_EXPLICIT': 'BLOCK_MEDIUM_AND_ABOVE',
+                'HARM_CATEGORY_DANGEROUS_CONTENT': 'BLOCK_MEDIUM_AND_ABOVE'
+            }
+        )
         
-        # Get the raw response
         if hasattr(response, 'text') and response.text:
             raw_response = response.text
+            st.session_state.raw_ai_response = raw_response
             
-            st.markdown("### 📥 Raw AI Response Received:")
-            st.text_area("Full Response:", raw_response, height=300)
+            # Show debug info if enabled
+            if st.session_state.ai_response_debug:
+                show_ai_response_debug(raw_response)
             
-            # Analyze the response
-            st.markdown("### 🔍 Response Analysis:")
+            # Extract JSON
+            plan = extract_json_robust(raw_response)
+            
+            if plan:
+                # Validate structure
+                if 'subject' not in plan:
+                    plan['subject'] = original_subject
+                if 'total_weeks' not in plan:
+                    plan['total_weeks'] = weeks
+                if 'weekly_schedule' not in plan:
+                    plan['weekly_schedule'] = []
+                
+                # Ensure correct number of weeks
+                while len(plan.get('weekly_schedule', [])) < weeks:
+                    week_num = len(plan['weekly_schedule']) + 1
+                    plan['weekly_schedule'].append({
+                        "week": week_num,
+                        "focus": f"Week {week_num}: {plan.get('subject', safe_subject)}",
+                        "objectives": ["Learn concepts", "Practice exercises", "Review material"],
+                        "daily_tasks": [
+                            ["Study materials", "Take notes"],
+                            ["Practice exercises", "Review concepts"],
+                            ["Work on projects", "Apply knowledge"],
+                            ["Review week", "Prepare for next"],
+                            ["Weekly assessment", "Plan ahead"]
+                        ],
+                        "day_focus": ["Learn", "Practice", "Apply", "Review", "Plan"],
+                        "week_summary": f"Week {week_num} progress",
+                        "resources": ["Online resources", "Practice materials"],
+                        "milestone": f"Complete Week {week_num}"
+                    })
+                
+                plan['generated_at'] = datetime.now().isoformat()
+                plan['total_days'] = days_available
+                plan['selected_topics'] = selected_topics
+                
+                return plan
+            else:
+                st.session_state.ai_error_message = "Failed to parse AI response as JSON"
+                
+                # Show debug even if not enabled (for errors)
+                show_ai_response_debug(raw_response, error="JSON parsing failed")
+                
+                return None
+        else:
+            st.session_state.ai_error_message = "Empty response from AI"
+            return None
             
-            # Check for common patterns
-            has_json_blocks = "```json" in raw_response or "```" in raw_response
-            has_explanations = any(phrase in raw_response.lower() for phrase in [
-                "here is", "here's", "the study plan", "i have", "created", "json format", 
-                "please note", "this plan", "you can", "remember"
-            ])
-            starts_with_json = raw_response.strip().startswith("{")
-            ends_with_json = raw_response.strip().endswith("}")
+    except Exception as e:
+        error_msg = str(e).lower()
+        if "quota" in error_msg or "exceeded" in error_msg:
+            st.session_state.api_quota_exceeded = True
+            st.session_state.ai_error_message = "API quota exceeded"
+        elif "invalid" in error_msg or "api key" in error_msg:
+            st.session_state.ai_error_message = "Invalid API key"
+        else:
+            st.session_state.ai_error_message = f"AI Error: {str(e)[:100]}"
+        
+        return None
+
+# ============================================
+# 📂 FILE HANDLING FUNCTIONS
+# ============================================
+
+def save_plan(plan, subject):
+    """Save study plan to file"""
+    os.makedirs("data", exist_ok=True)
+    filename = f"data/{subject.replace(' ', '_')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+    
+    try:
+        with open(filename, 'w', encoding='utf-8') as f:
+            json.dump(plan, f, indent=4, ensure_ascii=False)
+        return filename
+    except:
+        return None
+
+def generate_final_plan(api_key, plan_data, subject, learning_quality):
+    """Generate and save plan with proper error handling"""
+    try:
+        st.session_state.ai_error_message = ""
+        st.session_state.plan_generation_attempted = True
+        
+        # Generate plan with debug
+        plan = generate_study_plan_with_debug(api_key, **plan_data)
+        
+        if plan:
+            # Set session state
+            st.session_state.study_plan = plan
+            st.session_state.subject = subject
+            st.session_state.current_week = 1
+            st.session_state.plan_loaded = True
             
-            col1, col2, col3, col4 = st.columns(4)
-            with col1:
-                st.metric("Length", f"{len(raw_response)} chars")
-            with col2:
-                st.metric("Markdown", "✅" if has_json_blocks else "❌")
-            with col3:
-                st.metric("Explanations", "✅" if has_explanations else "❌")
-            with col4:
-                st.metric("Valid JSON", "✅" if starts_with_json and ends_with_json else "❌")
+            # Save plan
+            filename = save_plan(plan, subject)
             
-            # Show first and last 200 characters
-            st.markdown("#### 📊 First 200 characters:")
-            st.code(raw_response[:200], language="text")
+            if filename:
+                st.success(f"✅ Study plan generated and saved!")
+                st.info(f"📁 Plan saved as: {filename}")
             
-            st.markdown("#### 📊 Last 200 characters:")
-            st.code(raw_response[-200:], language="text")
+            return True
+        else:
+            if st.session_state.ai_error_message:
+                st.error(f"❌ {st.session_state.ai_error_message}")
+            else:
+                st.error("❌ Failed to generate study plan")
+            return False
             
-            # Try to extract JSON
-            st.markdown("### 🛠️ Attempting JSON Extraction:")
+    except Exception as e:
+        st.error(f"❌ Error: {str(e)[:100]}")
+        return False
+
+# ============================================
+# 📚 TOPIC SUGGESTIONS DATABASE
+# ============================================
+
+def get_topic_suggestions(subject):
+    """Get topic suggestions based on subject"""
+    topic_library = {
+        "python": [
+            "Python Basics & Syntax", "Data Types & Variables", "Control Flow", 
+            "Functions & Modules", "Object-Oriented Programming", "Error Handling",
+            "File Operations", "Libraries & Packages", "Data Structures",
+            "Algorithms", "Web Development", "Data Science", "Machine Learning"
+        ],
+        "web development": [
+            "HTML & CSS", "JavaScript Basics", "DOM Manipulation",
+            "React/Vue/Angular", "Node.js", "Express.js",
+            "REST APIs", "Database Integration", "Authentication",
+            "Deployment", "Performance Optimization", "Security"
+        ],
+        "data science": [
+            "Statistics Fundamentals", "Python for Data Science",
+            "NumPy & Pandas", "Data Visualization", "Machine Learning Basics",
+            "Data Cleaning", "Exploratory Data Analysis", "Feature Engineering"
+        ],
+        "machine learning": [
+            "Linear Algebra", "Calculus", "Probability",
+            "Supervised Learning", "Unsupervised Learning", "Neural Networks",
+            "Deep Learning", "Computer Vision", "Natural Language Processing"
+        ]
+    }
+    
+    subject_lower = subject.lower()
+    for key in topic_library:
+        if key in subject_lower:
+            return topic_library[key]
+    
+    return [
+        "Fundamentals & Basics", "Core Concepts", "Practical Applications",
+        "Advanced Techniques", "Tools & Software", "Best Practices",
+        "Problem Solving", "Project Work", "Review & Revision"
+    ]
+
+# ============================================
+# 🎪 MAIN APPLICATION LAYOUT
+# ============================================
+
+# Main header
+st.markdown('<h1 class="main-header">📚 AI Study Planner Pro</h1>', unsafe_allow_html=True)
+st.markdown('<p class="tagline">Plan → Track → Achieve | Your personal AI study assistant</p>', unsafe_allow_html=True)
+
+# API Status
+if not st.session_state.api_key:
+    st.warning("⚠️ **API Key Required:** Set GEMINI_API_KEY in Hugging Face Secrets for AI features.")
+elif st.session_state.api_quota_exceeded:
+    st.error("🚫 **API Quota Exceeded:** Please try again tomorrow.")
+else:
+    st.success("✅ **AI Features Ready:** You can generate study plans!")
+
+# Debug mode toggle (in sidebar if you add one, or at top)
+st.checkbox("🔧 Enable AI Response Debug Mode", 
+            value=st.session_state.ai_response_debug,
+            key="ai_response_debug",
+            help="Show raw AI response and debugging info when generating plans")
+
+# Create tabs
+tab1, tab2, tab3, tab4 = st.tabs([
+    "🎯 Define Goal", 
+    "📅 Study Plan", 
+    "✅ Track Progress", 
+    "📤 Export"
+])
+
+# ============================================
+# TAB 1: DEFINE GOAL WITH DEBUG
+# ============================================
+
+with tab1:
+    st.markdown('<h2 class="sub-header">Define Your Learning Goal</h2>', unsafe_allow_html=True)
+    
+    # Option 1: Upload Existing Plan
+    st.info("📤 **Option 1: Upload Existing Plan**")
+    uploaded_file = st.file_uploader("Upload your saved study plan (JSON)", type=['json'], key="upload_plan")
+    
+    if uploaded_file is not None and not st.session_state.plan_loaded:
+        try:
+            plan = json.load(uploaded_file)
+            if 'subject' in plan:
+                st.session_state.study_plan = plan
+                st.session_state.subject = plan['subject']
+                st.session_state.plan_loaded = True
+                st.success(f"✅ Plan loaded: {plan['subject']}")
+                st.rerun()
+        except:
+            st.error("❌ Error loading plan")
+    
+    st.markdown("---")
+    
+    # Option 2: Create New Plan
+    st.info("🎯 **Option 2: Create New Plan**")
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        st.subheader("🎯 Goal Definition")
+        
+        subject = st.text_input(
+            "Subject/Topic:",
+            value="",
+            placeholder="e.g., Python Programming, AWS Cloud, Spanish Language...",
+            help="What do you want to learn?"
+        )
+        
+        goal = st.text_area(
+            "Specific Learning Goal:",
+            value="",
+            placeholder="e.g., 'Master Python for data analysis', 'Prepare for AWS certification'...",
+            height=80
+        )
+        
+        # TOPIC SELECTOR
+        if subject:
+            st.subheader("📚 Topics to Learn")
+            topics = get_topic_suggestions(subject)
             
-            # Method 1: Direct parse
-            try:
-                parsed = json.loads(raw_response)
-                st.success("✅ Method 1: Direct JSON.parse() succeeded!")
-                st.json(parsed)
-                return raw_response
-            except json.JSONDecodeError as e:
-                st.error(f"❌ Method 1 failed: {e}")
+            selected_topics = st.multiselect(
+                "Choose topics (select up to 10):",
+                options=topics,
+                default=topics[:min(5, len(topics))] if topics else [],
+                max_selections=10,
+                help="Select specific topics you want to focus on"
+            )
             
-            # Method 2: Remove markdown
-            cleaned = raw_response.replace("```json", "").replace("```", "").strip()
-            try:
-                parsed = json.loads(cleaned)
-                st.success("✅ Method 2: After removing markdown succeeded!")
-                st.json(parsed)
-                return raw_response
-            except json.JSONDecodeError as e:
-                st.error(f"❌ Method 2 failed: {e}")
+            st.session_state.selected_topics = selected_topics
             
-            # Method 3: Extract between first { and last }
-            start = raw_response.find('{')
-            end = raw_response.rfind('}') + 1
+            if selected_topics:
+                st.success(f"✅ Selected {len(selected_topics)} topics")
+        
+        st.subheader("⏰ Time Availability")
+        
+        col1a, col2a = st.columns(2)
+        with col1a:
+            hours_per_day = st.slider("Hours per day:", 1, 8, 2)
+        with col2a:
+            days_available = st.slider("Total days available:", 7, 365, 60)
+        
+        st.write("**Preferred study days:**")
+        study_days = st.multiselect(
+            "Select days:",
+            ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
+            default=["Mon", "Tue", "Wed", "Thu", "Fri"],
+            label_visibility="collapsed"
+        )
+        st.session_state.study_days = study_days
+        
+    with col2:
+        st.subheader("🎓 Learning Preferences")
+        
+        current_level = st.selectbox(
+            "Current Level:",
+            ["Beginner", "Intermediate", "Advanced"],
+            index=0
+        )
+        
+        # Quality indicator
+        if study_days and days_available and hours_per_day:
+            study_days_count = len(study_days)
+            learning_quality = calculate_learning_quality(days_available, hours_per_day, study_days_count)
             
-            if start != -1 and end != -1:
-                extracted = raw_response[start:end]
-                st.code(f"Extracted JSON (chars {start} to {end}):\n{extracted[:500]}...", language="text")
-                
-                try:
-                    parsed = json.loads(extracted)
-                    st.success("✅ Method 3: Extract between {{}} succeeded!")
-                    st.json(parsed)
-                    return raw_response
-                except json.JSONDecodeError as e:
-                    st.error(f"❌ Method 3 failed: {e}")
-                    
-                    # Show where the error is
-                    st.markdown("#### 🐛 JSON Error Analysis:")
-                    try:
-                        # Try to find the problematic line
-                        lines = extracted.split('\n')
-                        for i, line in enumerate(lines):
-                            try:
-                                test = json.loads('{' + line + '}')
-                            except:
-                                st.warning(f"Problematic line {i+1}: {line[:100]}")
-                    except:
-                        pass
+            quality_score = learning_quality['quality_score']
+            color = "green" if quality_score >= 70 else "orange" if quality_score >= 40 else "red"
             
-            # Save the raw response for analysis
-            save_response = st.checkbox("💾 Save this response for analysis?")
-            if save_response:
-                with open(f"ai_response_{subject.replace(' ', '_')}.txt", "w") as f:
-                    f.write(f"PROMPT:\n{prompt}\n\n" + "="*80 + "\n\n" + f"RESPONSE:\n{raw_response}")
-                st.success(f"✅ Response saved to ai_response_{subject.replace(' ', '_')}.txt")
+            st.markdown(f"""
+            <div style="background-color: #F8FAFC; padding: 1rem; border-radius: 10px; border-left: 5px solid {color};">
+                <h4 style="margin: 0 0 10px 0;">📊 Learning Quality</h4>
+                <div style="font-size: 2rem; font-weight: bold; color: {color}; text-align: center;">
+                    {quality_score:.0f}/100
+                </div>
+                <p style="text-align: center; margin: 5px 0; color: #666;">
+                    {learning_quality['coverage_percentage']:.0f}% coverage
+                </p>
+                <div style="background-color: #E5E7EB; height: 10px; border-radius: 5px; margin: 10px 0;">
+                    <div style="background-color: {color}; width: {quality_score}%; height: 100%; border-radius: 5px;"></div>
+                </div>
+            </div>
+            """, unsafe_allow_html=True)
             
-            return raw_response
+            if learning_quality['is_severely_inadequate']:
+                st.warning("⚠️ **Low time allocation:** Consider increasing study hours.")
+            elif learning_quality['is_optimal']:
+                st.success("✅ **Optimal schedule:** Your study plan looks well-balanced!")
+    
+    st.markdown("---")
+    
+    # Generate Plan Button - WITH DEBUG
+    if st.button("🚀 Generate AI Study Plan", type="primary", use_container_width=True):
+        if not st.session_state.api_key:
+            st.error("⚠️ **API Key Required:** Please set GEMINI_API_KEY in Hugging Face Secrets.")
+        elif not subject:
+            st.error("⚠️ Please enter a Subject/Topic")
+        elif not study_days:
+            st.error("⚠️ Please select at least one study day")
         else:
-            st.error("❌ Empty response from AI")
-            return None
-            
-    except Exception as e:
-        st.error(f"❌ API Error: {str(e)}")
-        return None
+            with st.spinner("🤖 AI is crafting your personalized study plan..."):
+                try:
+                    study_days_count = len(study_days)
+                    learning_quality = calculate_learning_quality(days_available, hours_per_day, study_days_count)
+                    
+                    plan_data = {
+                        'subject': subject,
+                        'goal': goal,
+                        'selected_topics': st.session_state.selected_topics,
+                        'hours_per_day': hours_per_day,
+                        'days_available': days_available,
+                        'current_level': current_level,
+                        'study_days': study_days,
+                        'goal_type': "Skill/Topic Completion"
+                    }
+                    
+                    success = generate_final_plan(st.session_state.api_key, plan_data, subject, learning_quality)
+                    
+                    if success:
+                        st.rerun()
+                            
+                except Exception as e:
+                    st.error(f"❌ Error: {str(e)[:100]}")
 
-# Streamlit app for testing
-st.title("🔍 AI Response Debugger")
-st.markdown("Test what the Gemini AI actually returns for your study plan prompt")
+# ============================================
+# TAB 2: STUDY PLAN (Simplified)
+# ============================================
 
-subject = st.text_input("Subject/Topic:", "Python Programming")
-topics_input = st.text_area("Topics (comma-separated):", "Variables, Functions, Loops, Data Structures")
-topics = [t.strip() for t in topics_input.split(",") if t.strip()]
+with tab2:
+    if st.session_state.study_plan:
+        plan = st.session_state.study_plan
+        subject = st.session_state.subject
+        
+        st.markdown(f'<h2 class="sub-header">📅 Study Plan: {subject}</h2>', unsafe_allow_html=True)
+        
+        # Basic info
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            st.metric("Total Weeks", plan.get('total_weeks', 0))
+        with col2:
+            st.metric("Daily Hours", plan.get('daily_hours', 2))
+        with col3:
+            st.metric("Study Days", len(plan.get('study_days', [])))
+        
+        # Weekly schedule
+        st.subheader("📋 Weekly Schedule")
+        
+        current_week = st.selectbox(
+            "Select week:",
+            options=list(range(1, plan.get('total_weeks', 1) + 1)),
+            index=st.session_state.current_week - 1
+        )
+        
+        if plan.get('weekly_schedule'):
+            week_idx = current_week - 1
+            if week_idx < len(plan['weekly_schedule']):
+                week = plan['weekly_schedule'][week_idx]
+                
+                with st.expander(f"Week {week['week']}: {week.get('focus', '')}", expanded=True):
+                    st.write(f"**Objectives:**")
+                    for obj in week.get('objectives', []):
+                        st.write(f"• {obj}")
+                    
+                    st.write(f"**Milestone:** {week.get('milestone', '')}")
+                    
+                    # Daily tasks
+                    if 'daily_tasks' in week:
+                        st.write("**Daily Tasks:**")
+                        for day_idx, tasks in enumerate(week['daily_tasks']):
+                            st.write(f"Day {day_idx + 1}:")
+                            for task in tasks:
+                                st.write(f"  - {task}")
+    else:
+        st.info("👈 **Define your learning goal first in the 'Define Goal' tab!**")
+        
+        # Show debug info if available
+        if st.session_state.raw_ai_response and st.session_state.ai_response_debug:
+            show_ai_response_debug(st.session_state.raw_ai_response)
 
-col1, col2 = st.columns(2)
-with col1:
-    days = st.slider("Days available:", 7, 365, 60)
-with col2:
-    hours = st.slider("Hours per day:", 1, 8, 2)
+# ============================================
+# TAB 3: TRACK PROGRESS (Simplified)
+# ============================================
 
-study_days = st.multiselect(
-    "Study days:",
-    ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
-    default=["Mon", "Tue", "Wed", "Thu", "Fri"]
-)
+with tab3:
+    st.markdown('<h2 class="sub-header">✅ Progress Tracker</h2>', unsafe_allow_html=True)
+    
+    if st.session_state.study_plan:
+        st.info("📊 Progress tracking features will be available in the full version.")
+        st.write("Complete tasks in the Study Plan tab to track your progress.")
+    else:
+        st.info("👈 **Generate a study plan first to track progress!**")
 
-current_level = st.selectbox(
-    "Current Level:",
-    ["Beginner", "Intermediate", "Advanced"],
-    index=0
-)
+# ============================================
+# TAB 4: EXPORT (Simplified)
+# ============================================
+
+with tab4:
+    st.markdown('<h2 class="sub-header">📤 Export Your Study Plan</h2>', unsafe_allow_html=True)
+    
+    if st.session_state.study_plan:
+        plan = st.session_state.study_plan
+        subject = st.session_state.subject
+        
+        json_str = json.dumps(plan, indent=2, ensure_ascii=False)
+        
+        st.download_button(
+            label="📄 Download Study Plan (JSON)",
+            data=json_str,
+            file_name=f"study_plan_{subject.replace(' ', '_')}.json",
+            mime="application/json",
+            use_container_width=True
+        )
+    else:
+        st.info("👈 **Generate or load a study plan first to export!**")
+
+# ============================================
+# 📋 DEBUG INFO PANEL (Always available)
+# ============================================
 
-if st.button("🚀 Test AI Response", type="primary"):
-    test_ai_response(subject, topics, days, hours, study_days, current_level)
-
-st.markdown("---")
-st.markdown("### 📝 Sample Responses to Test Against:")
-st.code("""Example 1 (Good - pure JSON):
-{
-  "subject": "Python Programming",
-  "total_weeks": 8,
-  "daily_hours": 2,
-  ...
-}
-
-Example 2 (With markdown):
-```json
-{
-  "subject": "Python Programming",
-  "total_weeks": 8,
-  ...
-}
+if st.session_state.raw_ai_response and st.session_state.ai_response_debug:
+    st.markdown("---")
+    st.markdown("### 🔧 Debug Information")
+    
+    # Show the last raw response
+    with st.expander("View Last AI Response", expanded=False):
+        st.text_area("Raw AI Response:", 
+                    st.session_state.raw_ai_response, 
+                    height=300,
+                    label_visibility="collapsed")
+    
+    # Copy button for sharing
+    if st.button("📋 Copy Raw Response for Debugging"):
+        st.code(st.session_state.raw_ai_response, language="text")
+        st.success("Response ready to copy! Paste it in our chat for analysis.")
+
+# Instructions for debugging
+with st.expander("ℹ️ How to Debug JSON Parsing Issues", expanded=False):
+    st.markdown("""
+    **If you see "❌ Failed to parse AI response as JSON":**
+    
+    1. **Enable Debug Mode:** Check the "Enable AI Response Debug Mode" box above
+    2. **Click Generate Plan again**
+    3. **The debug panel will show:** 
+       - Raw AI response
+       - Response analysis
+       - JSON extraction attempts
+    
+    4. **Copy the raw response** and share it with me
+    5. **I'll create a fix** based on what the AI actually returns
+    
+    **Common Issues:**
+    - AI adds markdown blocks (\`\`\`json)
+    - AI adds explanatory text before/after JSON
+    - Smart quotes or invalid characters
+    - Missing or extra commas
+    """)