Update AdminDashboard.py

AdminDashboard.py

@@ -1,309 +1,696 @@
 import streamlit as st
-import boto3
-import time
+import json
 from datetime import datetime
+import time
+import requests
+import boto3
+import uuid
 import os
+from AdminDashboard import render_admin_dashboard
+
+# Load configuration from environment variables (Hugging Face Spaces)
+API_ENDPOINT = os.getenv("API_ENDPOINT", "https://oau6sljd4l.execute-api.ap-south-1.amazonaws.com/production/process")
 
-# DynamoDB configuration
+# DynamoDB configuration for session tracking
 DYNAMODB_REGION = os.getenv("DYNAMODB_REGION", "ap-south-1") 
 SESSION_TABLE = os.getenv("SESSION_TABLE", "SessionTracking")
-COURSE_TABLE = os.getenv("COURSE_TABLE", "CourseTracking")
 
 # AWS Configuration
 AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID")
 AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
+AWS_DEFAULT_REGION = os.getenv("AWS_DEFAULT_REGION", "ap-south-1")
 
-def fetch_courses():
-    """Fetch all courses from DynamoDB"""
-    try:
-        dynamodb = boto3.client(
-            "dynamodb",
-            region_name=DYNAMODB_REGION,
-            aws_access_key_id=AWS_ACCESS_KEY_ID,
-            aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
-        )
-        
-        response = dynamodb.scan(TableName=COURSE_TABLE)
-        items = response.get("Items", [])
-        courses = []
-        for item in items:
-            course_detail = item.get("course_detail", {}).get("M", {})
-            courses.append({
-                "course_id": item.get("course_id", {}).get("N"),
-                "course_name": item.get("course_name", {}).get("S"),
-                "total_videos": item.get("total_videos", {}).get("N", "0"),
-                "created_at": item.get("created_at", {}).get("S", "-"),
-                "topic_id": course_detail.get("topic_id", {}).get("N", "-"),
-                "chapter_id": course_detail.get("chapter_id", {}).get("N", "-"),
-            })
-        return courses
-    except Exception as e:
-        st.error(f"⚠️ Error fetching courses: {e}")
-        return []
+# Default values
+DEFAULT_USER_ID = int(os.getenv("DEFAULT_USER_ID", "30")) 
+DEFAULT_PERSONALIZATION_ID = int(os.getenv("DEFAULT_PERSONALIZATION_ID", "100"))
+API_TIMEOUT = int(os.getenv("API_TIMEOUT", "30"))
 
-def fetch_sessions():
-    """Fetch all sessions from DynamoDB"""
-    try:
-        dynamodb = boto3.client(
-            "dynamodb",
-            region_name=DYNAMODB_REGION,
-            aws_access_key_id=AWS_ACCESS_KEY_ID,
-            aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
-        )
-        
-        response = dynamodb.scan(TableName=SESSION_TABLE)
-        items = response.get("Items", [])
-        sessions = []
-        for item in items:
-            sessions.append({
-                "session_id": item.get("session_id", {}).get("S"),
-                "course_id": item.get("course_id", {}).get("N"),
-                "topic_id": item.get("topic_id", {}).get("N"),
-                "topic_title": item.get("topic_title", {}).get("S", "-"),
-                "status": item.get("status", {}).get("S", "unknown"),
-                "node": item.get("node", {}).get("S", "-"),
-                "created_at": item.get("created_at", {}).get("S", "-"),
-                "updated_at": item.get("updated_at", {}).get("S", "-"),
-                "video_url": item.get("video_url", {}).get("S", None),
-            })
-        return sessions
-    except Exception as e:
-        st.error(f"⚠️ Error fetching sessions: {e}")
-        return []
+# Authentication credentials from environment variables
+VALID_USERNAME = os.getenv("APP_USERNAME")
+VALID_PASSWORD = os.getenv("APP_PASSWORD")
 
-def get_sessions_by_course(course_id):
-    """Get sessions for a specific course"""
-    all_sessions = fetch_sessions()
-    return [session for session in all_sessions if session['course_id'] == str(course_id)]
+# Course configurations
+COURSE_CONFIGS = {
+    "AI Ready Course": {"course_id": 47, "chapter_id": 647},
+    "MERN": {"course_id": 48, "chapter_id": 648},
+    "Machine Learning": {"course_id": 49, "chapter_id": 649},
+    "Data Science": {"course_id": 50, "chapter_id": 650},
+    "Flask": {"course_id": 51, "chapter_id": 651},
+    "Django": {"course_id": 52, "chapter_id": 652}
+}
 
-def render_admin_dashboard():
-    """Render the admin dashboard page"""
-    st.markdown("<h1 style='color:#4F97FF;text-align:center;'>📊 Admin Dashboard</h1>", unsafe_allow_html=True)
+# Set page configuration
+st.set_page_config(
+    page_title="Base Course Personalization",
+    layout="wide",
+    initial_sidebar_state="collapsed",
+    page_icon="📚",
+    menu_items={
+        'Get Help': None,
+        'Report a bug': None,
+        'About': None
+    }
+)
+
+# Custom CSS for dark theme styling
+st.markdown("""
+<style>
+    /* Dark theme colors */
+    :root {
+        --background-color: #1E1E1E;
+        --card-background: #2D2D2D;
+        --text-color: #E0E0E0;
+        --accent-color: #4F97FF;
+        --border-color: #444444;
+        --header-color: #4F97FF;
+        --subheader-color: #FFFFFF;
+        --success-color: #10B981;
+        --warning-color: #F59E0B;
+        --error-color: #EF4444;
+    }
     
-    # Auto-refresh controls
-    col1, col2, col3 = st.columns([1, 1, 2])
-    with col1:
-        if st.button("🔄 Refresh Now", key="manual_refresh"):
-            st.rerun()
+    /* Main container styling */
+    .stApp {
+        background-color: var(--background-color);
+        color: var(--text-color);
+    }
     
-    with col2:
-        auto_refresh = st.toggle("Auto Refresh (30s)", value=False)
+    /* Headers */
+    .main-header {
+        font-size: 2.5rem;
+        font-weight: 600;
+        color: var(--header-color);
+        margin-bottom: 1rem;
+        text-align: center;
+        text-shadow: 0 2px 4px rgba(79, 151, 255, 0.3);
+    }
     
-    # Tabs for different views
-    tab1, tab2, tab3 = st.tabs(["📚 Courses Overview", "🎬 Sessions Overview", "📈 Course Details"])
+    .section-header {
+        font-size: 1.5rem;
+        font-weight: 500;
+        color: var(--subheader-color);
+        margin-top: 2rem;
+        margin-bottom: 1rem;
+        padding-bottom: 0.5rem;
+        border-bottom: 2px solid var(--border-color);
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+    }
     
-    with tab1:
-        render_courses_overview()
+    /* Form container */
+    div[data-testid="stForm"] {
+        background-color: var(--card-background);
+        padding: 2rem;
+        border-radius: 12px;
+        box-shadow: 0 8px 25px rgba(0,0,0,0.4);
+        border: 1px solid var(--border-color);
+        margin-bottom: 1rem;
+    }
     
-    with tab2:
-        render_sessions_overview()
-        
-    with tab3:
-        render_course_details()
+    /* Button styling */
+    .stButton>button {
+        background: linear-gradient(135deg, var(--accent-color) 0%, #3B82F6 100%);
+        color: white;
+        border-radius: 8px;
+        padding: 0.75rem 2rem;
+        font-weight: 600;
+        border: none;
+        transition: all 0.3s ease;
+        box-shadow: 0 4px 15px rgba(79, 151, 255, 0.3);
+    }
     
-    # Auto-refresh mechanism
-    if auto_refresh:
-        time.sleep(30)
-        st.rerun()
-
-def render_courses_overview():
-    """Render courses overview tab"""
-    st.markdown("### 📚 All Courses")
+    .stButton>button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 6px 20px rgba(79, 151, 255, 0.4);
+    }
     
-    courses = fetch_courses()
+    /* Input fields styling */
+    div[data-baseweb="select"] > div {
+        background-color: var(--background-color);
+        border: 2px solid var(--border-color);
+        border-radius: 8px;
+        transition: border-color 0.3s ease;
+    }
     
-    if not courses:
-        st.warning("No courses found yet.")
-        st.info("Courses will appear here once you create them from the Course Generation page.")
-        return
+    div[data-baseweb="select"] > div:focus-within {
+        border-color: var(--accent-color);
+        box-shadow: 0 0 0 3px rgba(79, 151, 255, 0.1);
+    }
     
-    # Display course count
-    st.markdown(f"**Total Courses: {len(courses)}**")
+    .stTextInput > div > div > input,
+    .stNumberInput > div > div > input,
+    .stTextArea > div > div > textarea {
+        background-color: var(--background-color);
+        color: var(--text-color);
+        border: 2px solid var(--border-color);
+        border-radius: 8px;
+        padding: 0.75rem;
+        transition: border-color 0.3s ease;
+    }
     
-    # Sort courses by created_at (newest first)
-    try:
-        courses.sort(key=lambda x: x['created_at'] if x['created_at'] != '-' else '1970-01-01', reverse=True)
-    except:
-        pass
+    .stTextInput > div > div > input:focus,
+    .stNumberInput > div > div > input:focus,
+    .stTextArea > div > div > textarea:focus {
+        border-color: var(--accent-color);
+        box-shadow: 0 0 0 3px rgba(79, 151, 255, 0.1);
+    }
     
-    # Display courses in cards
-    for i, course in enumerate(courses):
-        with st.container():
-            st.markdown(f"""
-            <div style="background:#2D2D2D;padding:1.5rem;border-radius:12px;margin-bottom:1rem;border:1px solid #444;">
-                <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:1rem;">
-                    <h4 style="color:#4F97FF;margin:0;">📚 {course['course_name']}</h4>
-                    <span style="background:#10B981;color:black;padding:0.3rem 0.8rem;border-radius:15px;font-size:0.8rem;font-weight:bold;">COURSE ID: {course['course_id']}</span>
-                </div>
-                <div style="display:grid;grid-template-columns:1fr 1fr 1fr;gap:1rem;">
-                    <div>
-                        <b>📹 Total Videos:</b><br><span style="color:#E0E0E0;">{course['total_videos']}</span>
-                    </div>
-                    <div>
-                        <b>🎯 Topic ID:</b><br><span style="color:#E0E0E0;">{course['topic_id']}</span>
-                    </div>
-                    <div>
-                        <b>📖 Chapter ID:</b><br><span style="color:#E0E0E0;">{course['chapter_id']}</span>
-                    </div>
-                </div>
-                <div style="margin-top:1rem;">
-                    <b>📅 Created:</b> <span style="color:#888;">{course['created_at'][:19] if course['created_at'] != '-' else '-'}</span>
-                </div>
-            </div>
-            """, unsafe_allow_html=True)
-
-def render_sessions_overview():
-    """Render sessions overview tab"""
-    st.markdown("### 🎬 All Sessions")
+    /* Topic container styling */
+    .topic-container {
+        background-color: var(--card-background);
+        padding: 1.5rem;
+        border-radius: 10px;
+        margin-bottom: 1rem;
+        border: 1px solid var(--border-color);
+        position: relative;
+    }
     
-    sessions = fetch_sessions()
+    .topic-header {
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+        margin-bottom: 1rem;
+        font-weight: 600;
+        color: var(--accent-color);
+    }
     
-    if not sessions:
-        st.warning("No sessions found yet.")
-        st.info("Sessions will appear here once you start generating courses.")
-        return
+    /* Radio buttons */
+    .stRadio > div {
+        background-color: transparent;
+        gap: 1rem;
+    }
     
-    # Display session count and status summary
-    col1, col2, col3, col4 = st.columns(4)
+    .stRadio > div > label > div {
+        color: var(--text-color) !important;
+        font-weight: 500;
+    }
     
-    status_counts = {}
-    for session in sessions:
-        status = session['status'].lower()
-        status_counts[status] = status_counts.get(status, 0) + 1
+    /* Labels */
+    .stSelectbox > label,
+    .stTextInput > label,
+    .stNumberInput > label,
+    .stTextArea > label,
+    .stRadio > label {
+        color: var(--text-color) !important;
+        font-weight: 500;
+        margin-bottom: 0.5rem;
+    }
     
-    with col1:
-        st.metric("📊 Total Sessions", len(sessions))
-    with col2:
-        completed = status_counts.get('completed', 0)
-        st.metric("✅ Completed", completed)
-    with col3:
-        processing = status_counts.get('processing', 0) + status_counts.get('in_progress', 0) + status_counts.get('running', 0)
-        st.metric("⏳ Processing", processing)
-    with col4:
-        failed = status_counts.get('failed', 0) + status_counts.get('error', 0)
-        st.metric("❌ Failed", failed)
+    /* Toggle switch */
+    .stToggle > label {
+        color: var(--text-color) !important;
+        font-weight: 500;
+    }
     
-    # Sort sessions by updated_at (newest first)
-    try:
-        sessions.sort(key=lambda x: x['updated_at'] if x['updated_at'] != '-' else '1970-01-01', reverse=True)
-    except:
-        pass
+    /* Spacing */
+    div.block-container {
+        padding-top: 2rem;
+        max-width: 1200px;
+    }
     
-    # Display sessions
-    for i, session in enumerate(sessions):
-        status_color = {
-            'completed': '#10B981',
-            'processing': '#F59E0B',
-            'in_progress': '#F59E0B', 
-            'running': '#F59E0B',
-            'failed': '#EF4444',
-            'error': '#EF4444'
-        }.get(session['status'].lower(), '#6B7280')
-        
-        with st.container():
-            st.markdown(f"""
-            <div style="background:#2D2D2D;padding:1.5rem;border-radius:12px;margin-bottom:1rem;border:1px solid #444;">
-                <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:1rem;">
-                    <h4 style="color:#4F97FF;margin:0;">🎬 {session['topic_title']}</h4>
-                    <span style="background:{status_color};color:white;padding:0.3rem 0.8rem;border-radius:15px;font-size:0.8rem;font-weight:bold;">{session['status'].upper()}</span>
-                </div>
-                <div style="display:grid;grid-template-columns:1fr 1fr 1fr;gap:1rem;">
-                    <div>
-                        <b>🆔 Session ID:</b><br><code style="background:#1A1A1A;padding:0.2rem;border-radius:4px;font-size:0.8rem;">{session['session_id'][:20]}...</code>
-                    </div>
-                    <div>
-                        <b>📚 Course ID:</b><br><span style="color:#E0E0E0;">{session['course_id']}</span>
-                    </div>
-                    <div>
-                        <b>🎯 Topic ID:</b><br><span style="color:#E0E0E0;">{session['topic_id']}</span>
-                    </div>
-                </div>
-                <div style="margin-top:1rem;display:flex;justify-content:space-between;">
-                    <div><b>🔧 Current Node:</b> <span style="color:#E0E0E0;">{session['node']}</span></div>
-                    <div><b>⏱️ Updated:</b> <span style="color:#888;">{session['updated_at'][:19] if session['updated_at'] != '-' else '-'}</span></div>
-                </div>
-                {f"<div style='margin-top:1rem;'><b>🎥 Video:</b> <a href='{session['video_url']}' target='_blank' style='color:#4F97FF;'>📺 Watch Video</a></div>" if session['video_url'] else ""}
-            </div>
-            """, unsafe_allow_html=True)
+    hr {
+        margin: 2rem 0;
+        border: none;
+        border-top: 1px solid var(--border-color);
+    }
+    
+    /* API Response Container */
+    .api-response {
+        background-color: #1A1A1A;
+        border-radius: 10px;
+        padding: 1.5rem;
+        border-left: 4px solid var(--accent-color);
+        margin: 1rem 0;
+    }
+    
+    .session-info {
+        background-color: var(--card-background);
+        padding: 1.5rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+        border: 1px solid var(--border-color);
+        box-shadow: 0 4px 12px rgba(0,0,0,0.2);
+    }
+    
+    /* Action buttons container */
+    .action-buttons {
+        display: flex;
+        gap: 1rem;
+        margin: 1rem 0;
+        justify-content: flex-start;
+    }
+    
+    /* Small action buttons */
+    .small-button {
+        padding: 0.5rem 1rem;
+        font-size: 0.875rem;
+    }
+    
+    /* Success/Error styling */
+    .stSuccess, .stError, .stWarning, .stInfo {
+        border-radius: 8px;
+        padding: 1rem;
+        margin: 1rem 0;
+    }
+    
+    /* Login container */
+    .login-container {
+        background-color: var(--card-background);
+        padding: 3rem;
+        border-radius: 15px;
+        box-shadow: 0 10px 30px rgba(0,0,0,0.5);
+        border: 1px solid var(--border-color);
+    }
+    
+    /* Navigation tab styling */
+    .nav-tabs {
+        background-color: var(--card-background);
+        padding: 1rem;
+        border-radius: 10px;
+        margin-bottom: 2rem;
+        border: 1px solid var(--border-color);
+    }
+</style>
+""", unsafe_allow_html=True)
 
-def render_course_details():
-    """Render detailed course view with sessions"""
-    st.markdown("### 📈 Detailed Course View")
+# Initialize session state for topics and authentication
+if 'topics_list' not in st.session_state:
+    st.session_state.topics_list = [{"topic_title": "What is Flask", "chapter_title": "Introduction to Flask"}]
+if 'session_ids' not in st.session_state:
+    st.session_state.session_ids = []
+if 'authenticated' not in st.session_state:
+    st.session_state.authenticated = False
+if 'current_page' not in st.session_state:
+    st.session_state.current_page = "Course Generation"
+
+# Authentication check
+if not st.session_state.authenticated:
+    st.markdown('<h1 class="main-header">🔐 Login to Course Management</h1>', unsafe_allow_html=True)
     
-    courses = fetch_courses()
+    # Check if credentials are configured
+    if not VALID_USERNAME or not VALID_PASSWORD:
+        st.error("❌ Authentication credentials not configured. Please contact administrator.")
+        st.stop()
     
-    if not courses:
-        st.warning("No courses found.")
-        return
+    col1, col2, col3 = st.columns([1, 2, 1])
+    with col2:
+        with st.container():
+            st.markdown('<div class="login-container">', unsafe_allow_html=True)
+            
+            with st.form("login_form"):
+                st.markdown('<div class="section-header">🔑 Authentication Required</div>', unsafe_allow_html=True)
+                
+                username = st.text_input("Username", placeholder="Enter username", key="login_username")
+                password = st.text_input("Password", placeholder="Enter password", type="password", key="login_password")
+                
+                login_submitted = st.form_submit_button("🚀 Login", use_container_width=True)
+                
+                if login_submitted:
+                    if VALID_USERNAME and VALID_PASSWORD and username == VALID_USERNAME and password == VALID_PASSWORD:
+                        st.session_state.authenticated = True
+                        st.success("Login successful! Redirecting...")
+                        time.sleep(1)
+                        st.rerun()
+                    else:
+                        st.error("❌ Invalid username or password")
+            
+            st.markdown('</div>', unsafe_allow_html=True)
     
-    # Course selection
-    course_options = {f"{course['course_name']} (ID: {course['course_id']})": course['course_id'] for course in courses}
+    st.markdown("---")
+    st.markdown("""
+    <div style="text-align: center; color: #888888;">
+    <small>Please contact administrator for access credentials</small>
+    </div>
+    """, unsafe_allow_html=True)
+    st.stop()
+
+# Navigation and Header (after login)
+col1, col2, col3, col4 = st.columns([3, 2, 2, 1])
+with col1:
+    st.markdown('<h1 class="main-header">📚 Course Management System</h1>', unsafe_allow_html=True)
+
+with col2:
+    page = st.selectbox(
+        "📋 Navigate to:",
+        ["Course Generation", "Admin Dashboard"],
+        index=0 if st.session_state.current_page == "Course Generation" else 1,
+        key="page_selector"
+    )
+    st.session_state.current_page = page
+
+with col4:
+    if st.button("🔓 Logout", key="logout_btn"):
+        st.session_state.authenticated = False
+        st.session_state.topics_list = [{"topic_title": "What is Flask", "chapter_title": "Introduction to Flask"}]
+        st.session_state.session_ids = []
+        st.session_state.current_page = "Course Generation"
+        st.rerun()
+
+# Page routing
+if st.session_state.current_page == "Admin Dashboard":
+    render_admin_dashboard()
+else:
+    # Course Generation Page (Original Content)
+    
+    # Course Selection Section
+    st.markdown('<div class="section-header">📚 Course Selection</div>', unsafe_allow_html=True)
     
-    if course_options:
-        selected_course_display = st.selectbox(
-            "Select a course to view details:",
-            options=list(course_options.keys()),
-            key="course_detail_selector"
+    col1, col2 = st.columns([2, 3])
+    with col1:
+        selected_course = st.selectbox(
+            "Select Course Type",
+            options=list(COURSE_CONFIGS.keys()),
+            index=0,
+            help="Choose the course you want to generate content for"
         )
+    
+    with col2:
+        st.info(f"**Selected:** {selected_course} (Course ID: {COURSE_CONFIGS[selected_course]['course_id']})")
+
+    # Topics Section (Outside form for dynamic interaction)
+    st.markdown('<div class="section-header">📋 Topics Configuration</div>', unsafe_allow_html=True)
+
+    # Display existing topics with better styling
+    for i, topic in enumerate(st.session_state.topics_list):
+        st.markdown(f'<div class="topic-container">', unsafe_allow_html=True)
+        st.markdown(f'<div class="topic-header">📖 Topic {i+1}</div>', unsafe_allow_html=True)
         
-        selected_course_id = course_options[selected_course_display]
-        selected_course = next(course for course in courses if course['course_id'] == str(selected_course_id))
+        col1, col2, col3 = st.columns([3, 3, 1])
+        with col1:
+            topic_title = st.text_input(
+                "Topic Title", 
+                value=topic["topic_title"], 
+                key=f"topic_title_{i}",
+                help="Enter the topic title"
+            )
+            st.session_state.topics_list[i]["topic_title"] = topic_title
         
-        # Display course information
-        st.markdown(f"""
-        <div style="background:#2D2D2D;padding:2rem;border-radius:12px;margin-bottom:2rem;border:1px solid #444;">
-            <h3 style="color:#4F97FF;margin-bottom:1rem;">📚 {selected_course['course_name']}</h3>
-            <div style="display:grid;grid-template-columns:1fr 1fr 1fr;gap:1rem;">
-                <div><b>🆔 Course ID:</b> {selected_course['course_id']}</div>
-                <div><b>📹 Total Videos:</b> {selected_course['total_videos']}</div>
-                <div><b>📅 Created:</b> {selected_course['created_at'][:19] if selected_course['created_at'] != '-' else '-'}</div>
-            </div>
-        </div>
-        """, unsafe_allow_html=True)
+        with col2:
+            chapter_title = st.text_input(
+                "Chapter Title", 
+                value=topic["chapter_title"], 
+                key=f"chapter_title_{i}",
+                help="Enter the chapter title"
+            )
+            st.session_state.topics_list[i]["chapter_title"] = chapter_title
         
-        # Get sessions for this course
-        course_sessions = get_sessions_by_course(selected_course_id)
+        with col3:
+            if len(st.session_state.topics_list) > 1:
+                st.markdown("<br>", unsafe_allow_html=True)  # Add spacing
+                if st.button("🗑️", key=f"remove_{i}", help="Remove this topic"):
+                    st.session_state.topics_list.pop(i)
+                    st.rerun()
         
-        if course_sessions:
-            st.markdown(f"#### 🎬 Sessions for this Course ({len(course_sessions)} sessions)")
-            
-            # Session status summary for this course
-            col1, col2, col3 = st.columns(3)
-            course_status_counts = {}
-            for session in course_sessions:
-                status = session['status'].lower()
-                course_status_counts[status] = course_status_counts.get(status, 0) + 1
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    # Add/Remove topic buttons outside the form
+    st.markdown('<div class="action-buttons">', unsafe_allow_html=True)
+    col1, col2, col3, col4 = st.columns([2, 2, 2, 4])
+    with col1:
+        if st.button("➕ Add Topic", key="add_topic", help="Add a new topic"):
+            st.session_state.topics_list.append({
+                "topic_title": f"Topic {len(st.session_state.topics_list) + 1}", 
+                "chapter_title": f"Chapter {len(st.session_state.topics_list) + 1}"
+            })
+            st.rerun()
+    with col2:
+        if st.button("🔄 Reset All", key="reset_topics", help="Reset to default topics"):
+            st.session_state.topics_list = [{"topic_title": "What is Flask", "chapter_title": "Introduction to Flask"}]
+            st.rerun()
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # Main Form (for settings and submission)
+    with st.form("personalization_form", clear_on_submit=False):
+        # Language & Voice Settings Section  
+        st.markdown('<div class="section-header">🗣️ Language & Voice Settings</div>', unsafe_allow_html=True)
+        
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            target_language = st.selectbox(
+                "Target Language", 
+                ["english", "hindi", "marathi", "kannada", "punjabi","gujarati"],
+                index=0,
+                format_func=lambda x: x.capitalize(),
+                help="Select the target language for content generation"
+            )
+        
+        with col2:
+            tts_gender = st.selectbox(
+                "Voice Gender", 
+                ["male", "female"], 
+                index=0,
+                format_func=lambda x: x.capitalize(),
+                help="Select the voice gender for text-to-speech"
+            )
+        
+        with col3:
+            tts_voice = st.selectbox(
+                "Voice Style", 
+                ["alloy", "echo", "fable", "onyx", "nova", "shimmer"],
+                index=3,  # Default to "onyx"
+                format_func=lambda x: x.capitalize(),
+                help="Select the voice style for text-to-speech"
+            )
+
+        # Technical Settings Section
+        st.markdown('<div class="section-header">💻 Technical Settings</div>', unsafe_allow_html=True)
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            # Comprehensive list of programming languages, frameworks, and databases
+            tech_options = [
+                # Programming Languages
+                "Python", "Java", "JavaScript", "TypeScript", "C++", "C#", "C", "Go", "Rust", "Swift", 
+                "Kotlin", "Scala", "Ruby", "PHP", "Perl", "R", "MATLAB", "Dart", "Objective-C", "Assembly",
+                "Haskell", "Erlang", "Elixir", "F#", "Clojure", "Lua", "Julia", "Groovy", "VB.NET", "COBOL",
+                "Fortran", "Pascal", "Delphi", "Ada", "Prolog", "Lisp", "Scheme", "OCaml", "ML",
+                
+                # Web Technologies
+                "HTML", "CSS", "SASS", "LESS", "Bootstrap", "Tailwind CSS", "Material-UI",
+                
+                # Frontend Frameworks/Libraries
+                "React", "Vue.js", "Angular", "Svelte", "Next.js", "Nuxt.js", "Gatsby", "Ember.js", 
+                "Backbone.js", "jQuery", "Alpine.js", "Lit", "Stencil", "Ionic", "React Native", 
+                "Flutter", "Xamarin", "Cordova", "PhoneGap",
+                
+                # Backend Frameworks
+                "Node.js", "Express.js", "Nest.js", "Django", "Flask", "FastAPI", "Pyramid", "Tornado",
+                "Spring Boot", "Spring MVC", "Struts", "Hibernate", "ASP.NET", "ASP.NET Core", 
+                "Ruby on Rails", "Sinatra", "Laravel", "Symfony", "CodeIgniter", "CakePHP", "Zend",
+                "Gin", "Echo", "Fiber", "Actix", "Rocket", "Warp", "Axum",
+                
+                # Mobile Development
+                "Android (Java)", "Android (Kotlin)", "iOS (Swift)", "iOS (Objective-C)", 
+                
+                # Game Development
+                "Unity", "Unreal Engine", "Godot", "GameMaker Studio", "Construct", "Phaser",
+                
+                # Database Technologies
+                "MySQL", "PostgreSQL", "SQLite", "Microsoft SQL Server", "Oracle Database", 
+                "MongoDB", "Redis", "Cassandra", "DynamoDB", "Firebase", "Supabase", 
+                "CouchDB", "Neo4j", "InfluxDB", "TimescaleDB", "ClickHouse", "Apache Spark",
+                "Elasticsearch", "Apache Solr", "Amazon RDS", "Google Cloud SQL",
+                
+                # Cloud & DevOps
+                "AWS", "Google Cloud Platform", "Microsoft Azure", "Digital Ocean", "Heroku",
+                "Docker", "Kubernetes", "Terraform", "Ansible", "Jenkins", "GitLab CI", "GitHub Actions",
+                "Nginx", "Apache", "Linux", "Ubuntu", "CentOS", "Red Hat",
+                
+                # Data Science & AI/ML
+                "TensorFlow", "PyTorch", "Scikit-learn", "Pandas", "NumPy", "Matplotlib", "Seaborn",
+                "Jupyter", "Apache Airflow", "Apache Kafka", "Apache Flink", "Hadoop", "Spark",
+                "Tableau", "Power BI", "D3.js", "Plotly", "OpenCV", "Keras", "XGBoost",
+                
+                # Testing Frameworks
+                "Jest", "Mocha", "Chai", "Cypress", "Selenium", "Playwright", "Puppeteer",
+                "JUnit", "TestNG", "Mockito", "PyTest", "unittest", "RSpec", "PHPUnit",
+                
+                # Other Technologies
+                "GraphQL", "REST API", "gRPC", "WebSocket", "Apache Kafka", "RabbitMQ", 
+                "Blockchain", "Solidity", "Web3", "Ethereum", "Bitcoin", "Smart Contracts",
+                "Microservices", "Serverless", "Lambda Functions", "API Gateway"
+            ]
             
-            with col1:
-                completed = course_status_counts.get('completed', 0)
-                st.metric("✅ Completed", completed)
-            with col2:
-                processing = course_status_counts.get('processing', 0) + course_status_counts.get('in_progress', 0) + course_status_counts.get('running', 0)
-                st.metric("⏳ Processing", processing)
-            with col3:
-                failed = course_status_counts.get('failed', 0) + course_status_counts.get('error', 0)
-                st.metric("❌ Failed", failed)
+            # Sort the options alphabetically
+            tech_options.sort()
             
-            # Display sessions in a table format
-            for session in course_sessions:
-                status_color = {
-                    'completed': '#10B981',
-                    'processing': '#F59E0B',
-                    'in_progress': '#F59E0B', 
-                    'running': '#F59E0B',
-                    'failed': '#EF4444',
-                    'error': '#EF4444'
-                }.get(session['status'].lower(), '#6B7280')
-                
-                st.markdown(f"""
-                <div style="background:#1E1E1E;padding:1rem;border-radius:8px;margin-bottom:0.5rem;border-left:4px solid {status_color};">
-                    <div style="display:flex;justify-content:between;align-items:center;">
-                        <div style="flex:2;"><b>{session['topic_title']}</b></div>
-                        <div style="flex:1;text-align:center;"><span style="background:{status_color};color:white;padding:0.2rem 0.6rem;border-radius:10px;font-size:0.75rem;">{session['status'].upper()}</span></div>
-                        <div style="flex:1;text-align:right;color:#888;font-size:0.8rem;">{session['node']}</div>
-                    </div>
-                    {f"<div style='margin-top:0.5rem;'><a href='{session['video_url']}' target='_blank' style='color:#4F97FF;font-size:0.8rem;'>🎥 Watch Video</a></div>" if session['video_url'] else ""}
-                </div>
-                """, unsafe_allow_html=True)
+            programming_language = st.selectbox(
+                "Programming Language / Technology", 
+                tech_options,
+                index=tech_options.index("Python") if "Python" in tech_options else 0,
+                help="Select the primary programming language, framework, or technology for examples"
+            )
+        with col2:
+            st.markdown("<br>", unsafe_allow_html=True)  # Add spacing
+            toggle_hinglish = st.toggle("Enable Hinglish", value=True, help="Enable mixing of Hindi and English")
+
+        # Submit button
+        st.markdown("<br>", unsafe_allow_html=True)
+        col1, col2, col3 = st.columns([1, 2, 1])
+        with col2:
+            submitted = st.form_submit_button("🚀 Generate Course", use_container_width=True)
+
+    # Handle submission
+    if submitted:
+        # Use the topics from session state directly
+        topics_to_process = st.session_state.topics_list
+        
+        # Get course configuration
+        course_config = COURSE_CONFIGS[selected_course]
+        course_id = course_config["course_id"]
+        chapter_id = course_config["chapter_id"]
+        
+        # Validate inputs
+        valid_topics = []
+        for topic in topics_to_process:
+            if topic["topic_title"].strip() and topic["chapter_title"].strip():
+                valid_topics.append(topic)
+        
+        if not valid_topics:
+            st.error("❌ Please enter at least one topic with both topic title and chapter title")
         else:
-            st.info("No sessions found for this course yet.")
+            # Show loading state with better animation
+            with st.spinner(f"🎬 Generating your {selected_course} course... This may take a few moments."):
+                progress_bar = st.progress(0)
+                for i in range(100):
+                    time.sleep(0.02)  # Simulating progress
+                    progress_bar.progress(i + 1)
+                
+                # Hardcoded values
+                user_id = DEFAULT_USER_ID 
+                personalization_id = DEFAULT_PERSONALIZATION_ID
+                
+                # Create user profile (hardcoded)
+                user_profile = {
+                    "personalized": True,
+                    "user_name": "System User",
+                    "user_age": 25,
+                    "user_gender": "male",
+                    "user_tech_knowledge": "beginner",
+                    "user_preferred_activity": "coding, learning, technology",
+                    "user_food": "healthy food, vegetarian",
+                    "user_physical_activities": "walking, yoga",
+                    "learning_style": "visual",
+                    "target_language": target_language,
+                    "tts_gender": tts_gender,
+                    "tts_voice": tts_voice,
+                    "toggle_hinglish": toggle_hinglish,
+                    "run_visualization": False,
+                    "subtitle": "",
+                    "age_group": "18-25"
+                }
+                
+                # Create settings
+                settings = {
+                    "target_language": target_language,
+                    "tts_gender": tts_gender,
+                    "tts_voice": tts_voice,
+                    "toggle_hinglish": toggle_hinglish,
+                    "run_visualization": False,
+                    "subtitle": "",
+                    "programming_language": programming_language,
+                    "slide_colour": "blue",
+                    "video_type": "base_video"
+                }
+                
+                # Generate topics data with user input for titles and course-specific values
+                topics_data = []
+                for i, topic in enumerate(valid_topics):
+                    topics_data.append({
+                        "topic_id": 10834 + i,  # Hardcoded with increment
+                        "topic_title": topic["topic_title"].strip(),
+                        "chapter_id": chapter_id,  # From selected course
+                        "chapter_title": topic["chapter_title"].strip(),  # User input
+                        "course_id": course_id,  # From selected course
+                        "video_url": f"https://techlearn-dev.s3.ap-south-1.amazonaws.com/course_videos/{course_id}/{chapter_id}/172906{4365+i*50}.mp4",  # Course-specific
+                        "video_duration": 462 + i*20,  # Hardcoded with variation
+                        "sequence_number": i + 1,
+                    })
+                
+                # Create payload (always multiple topics structure)
+                payload = {
+                    "personalization_id": personalization_id,
+                    "user_id": user_id,
+                    "course_id": course_id,
+                    "total_videos": len(topics_data),
+                    "created_at": datetime.utcnow().isoformat(),
+                    "user_profile": user_profile,
+                    "topics": topics_data,
+                    "settings": settings
+                }
+
+                # Make API call
+                try:
+                    headers = {
+                        'Content-Type': 'application/json'
+                    }
+                    
+                    response = requests.post(API_ENDPOINT, json=payload, headers=headers, timeout=API_TIMEOUT)
+                    
+                    if response.status_code == 200:
+                        response_data = response.json()
+                        session_ids = response_data.get("session_ids", [])
+                        
+                        st.success(f"🎉 {selected_course} generation started successfully!")
+                        
+                        # Store session IDs in session state
+                        st.session_state.session_ids.extend(session_ids)
+                        
+                        # Display results in a clean format
+                        st.markdown("### 📊 Generation Summary")
+                        
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            st.markdown(f"""
+                            **Course**: {selected_course}  
+                            **Course ID**: {course_id}  
+                            **Programming Language**: {programming_language.capitalize()}  
+                            **Target Language**: {target_language.capitalize()}  
+                            """)
+                        with col2:
+                            st.markdown(f"""
+                            **Voice**: {tts_voice.capitalize()} ({tts_gender.capitalize()})  
+                            **Topics Count**: {len(valid_topics)}  
+                            **Hinglish**: {"Enabled" if toggle_hinglish else "Disabled"}  
+                            **Chapter ID**: {chapter_id}
+                            """)
+                        
+                        # Display session IDs
+                        if session_ids:
+                            st.markdown("### 🔍 Session Tracking IDs")
+                            for i, session_id in enumerate(session_ids, 1):
+                                st.markdown(f'<div class="session-info">📝 <strong>Session {i}:</strong> <code>{session_id}</code></div>', unsafe_allow_html=True)
+                        
+                        # Display API response
+                        with st.expander("📊 View Full API Response", expanded=False):
+                            st.markdown('<div class="api-response">', unsafe_allow_html=True)
+                            st.json(response_data)
+                            st.markdown('</div>', unsafe_allow_html=True)
+                        
+                        # Information about tracking
+                        st.info(f"""
+                        💡 **Tracking Information**  
+                        You can track the progress of your {selected_course} course generation using the session IDs above.  
+                        The processing status will be updated in DynamoDB table: {SESSION_TABLE}  
+                        Region: {DYNAMODB_REGION}
+                        
+                        👉 **Next Steps**: Switch to the "Admin Dashboard" to monitor your session progress in real-time!
+                        """)
+                        
+                    else:
+                        st.error(f"❌ API Error: {response.status_code}")
+                        if response.text:
+                            st.error(f"**Error Details**: {response.text}")
+                            
+                except requests.exceptions.Timeout:
+                    st.error("⏰ Request timed out. Please try again later.")
+                except requests.exceptions.ConnectionError:
+                    st.error("🌐 Connection error. Please check your internet connection.")
+                except Exception as e:
+                    st.error(f"❌ API call failed: {str(e)}")
+                    
+                    # Show payload for debugging
+                    with st.expander("🐛 Debug Information", expanded=False):
+                        st.warning("Request payload for debugging:")
+                        st.json(payload)