Update app.py

app.py

@@ -2,12 +2,12 @@ import streamlit as st
 import json
 import time
 import random
-from datetime import datetime, timedelta
+from datetime import datetime
 
 # Set page config
 st.set_page_config(
-    page_title="Training Content Health Check",
-    page_icon="🔍",
+    page_title="Training Course Outline Generator",
+    page_icon="📚",
     layout="wide",
     initial_sidebar_state="collapsed"
 )
@@ -35,102 +35,12 @@ st.markdown("""
         margin-bottom: 10px;
         font-weight: 600;
     }
-    .results-container {
+    .generated-outline {
         border: 1px solid #ddd;
         border-radius: 5px;
         padding: 20px;
         background-color: white;
-        margin-bottom: 20px;
-    }
-    .status-card {
-        border: 2px solid #e0e0e0;
-        border-radius: 12px;
-        padding: 20px;
-        margin-bottom: 20px;
-        text-align: center;
-    }
-    .status-excellent {
-        border-color: #28a745;
-        background-color: #f8fff9;
-    }
-    .status-good {
-        border-color: #ffc107;
-        background-color: #fffdf0;
-    }
-    .status-needs-attention {
-        border-color: #fd7e14;
-        background-color: #fff8f0;
-    }
-    .status-critical {
-        border-color: #dc3545;
-        background-color: #fff5f5;
-    }
-    .status-title {
-        font-size: 1.8rem;
-        font-weight: 700;
-        margin-bottom: 10px;
-    }
-    .status-description {
-        font-size: 1.1rem;
-        margin-bottom: 15px;
-    }
-    .status-score {
-        font-size: 2.5rem;
-        font-weight: 800;
-        margin-bottom: 10px;
-    }
-    .recommendation-card {
-        border: 1px solid #e0e0e0;
-        border-radius: 8px;
-        padding: 15px;
-        margin-bottom: 15px;
-        background-color: #fafafa;
-    }
-    .recommendation-title {
-        font-size: 1.1rem;
-        font-weight: 600;
-        color: #2c3e50;
-        margin-bottom: 8px;
-    }
-    .priority-high {
-        border-left: 4px solid #dc3545;
-    }
-    .priority-medium {
-        border-left: 4px solid #ffc107;
-    }
-    .priority-low {
-        border-left: 4px solid #28a745;
-    }
-    .question-card {
-        background-color: white;
-        border: 1px solid #e0e0e0;
-        border-radius: 8px;
-        padding: 20px;
-        margin-bottom: 20px;
-    }
-    .question-number {
-        background-color: #007bff;
-        color: white;
-        border-radius: 50%;
-        width: 30px;
-        height: 30px;
-        display: inline-flex;
-        align-items: center;
-        justify-content: center;
-        font-weight: 600;
-        margin-right: 10px;
-    }
-    .progress-bar {
-        height: 8px;
-        background-color: #e9ecef;
-        border-radius: 4px;
-        overflow: hidden;
-        margin-bottom: 20px;
-    }
-    .progress-fill {
-        height: 100%;
-        background-color: #007bff;
-        transition: width 0.3s ease;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
     }
     .stButton button {
         width: 100%;
@@ -140,6 +50,18 @@ st.markdown("""
         color: #6c757d;
         margin-top: 2rem;
     }
+    .settings-section {
+        background-color: #f8f9fa;
+        padding: 15px;
+        border-radius: 5px;
+        margin-bottom: 20px;
+    }
+    .examples-section {
+        background-color: #e9f7fe;
+        padding: 15px;
+        border-radius: 5px;
+        margin-bottom: 20px;
+    }
     .placeholder-area {
         border: 2px dashed #ddd;
         border-radius: 10px;
@@ -148,27 +70,43 @@ st.markdown("""
         background-color: #f8f9fa;
         color: #666;
     }
-    .stats-container {
-        display: flex;
-        justify-content: space-around;
-        margin: 20px 0;
-    }
-    .stat-item {
-        text-align: center;
-        padding: 15px;
+    .metric-card {
         background-color: #f8f9fa;
+        padding: 15px;
+        border-radius: 8px;
+        border-left: 4px solid #007bff;
+        margin-bottom: 15px;
+    }
+    .outline-section {
+        background-color: #ffffff;
+        padding: 20px;
         border-radius: 8px;
-        margin: 0 5px;
-        flex: 1;
+        margin-bottom: 20px;
+        border: 1px solid #e9ecef;
+    }
+    .success-indicator {
+        background-color: #d4edda;
+        color: #155724;
+        padding: 10px;
+        border-radius: 5px;
+        border: 1px solid #c3e6cb;
+        margin-bottom: 15px;
     }
-    .stat-number {
-        font-size: 1.5rem;
-        font-weight: 700;
-        color: #007bff;
+    .recommendation {
+        background-color: #fff3cd;
+        color: #856404;
+        padding: 15px;
+        border-radius: 5px;
+        border: 1px solid #ffeaa7;
+        margin-top: 15px;
     }
-    .stat-label {
-        font-size: 0.9rem;
-        color: #6c757d;
+    .partnership-cta {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 20px;
+        border-radius: 10px;
+        text-align: center;
+        margin-top: 20px;
     }
 </style>
 """, unsafe_allow_html=True)
@@ -176,585 +114,464 @@ st.markdown("""
 # Title and description
 st.markdown("""
 <div class="title-area">
-    <h1>Training Content Health Check 🔍</h1>
-    <p>Assess whether your training content is still effective and relevant. Get personalized recommendations to keep your content fresh and engaging!</p>
+    <h1>Training Course Outline Generator 📚</h1>
+    <p>Transform your training ideas into structured, actionable course outlines. Perfect for L&D leaders planning their next training initiative!</p>
 </div>
 """, unsafe_allow_html=True)
 
 # Initialize session state
-if "assessment_complete" not in st.session_state:
-    st.session_state["assessment_complete"] = False
-if "current_question" not in st.session_state:
-    st.session_state["current_question"] = 0
-if "answers" not in st.session_state:
-    st.session_state["answers"] = {}
-if "assessment_results" not in st.session_state:
-    st.session_state["assessment_results"] = None
+if "generated_outline" not in st.session_state:
+    st.session_state["generated_outline"] = None
+if "course_history" not in st.session_state:
+    st.session_state["course_history"] = []
 
-# Assessment questions
-ASSESSMENT_QUESTIONS = [
-    {
-        "id": "content_age",
-        "question": "When was your training content last updated?",
-        "type": "single_choice",
-        "options": [
-            ("Within the last 6 months", 5),
-            ("6 months to 1 year ago", 4),
-            ("1-2 years ago", 3),
-            ("2-3 years ago", 2),
-            ("More than 3 years ago", 1)
-        ],
-        "help": "Newer content is generally more relevant and effective"
-    },
-    {
-        "id": "industry_changes",
-        "question": "Have there been significant changes in your industry since the content was created?",
-        "type": "single_choice",
-        "options": [
-            ("No significant changes", 5),
-            ("Minor changes that don't affect the content", 4),
-            ("Some changes that might impact relevance", 3),
-            ("Significant changes that likely impact content", 2),
-            ("Major industry transformation", 1)
-        ],
-        "help": "Industry evolution can quickly make training content obsolete"
-    },
-    {
-        "id": "technology_updates",
-        "question": "If your training involves technology or software, how current are the versions covered?",
-        "type": "single_choice",
-        "options": [
-            ("Current/latest versions", 5),
-            ("One version behind", 4),
-            ("2-3 versions behind", 3),
-            ("Significantly outdated versions", 2),
-            ("Legacy/deprecated technology", 1),
-            ("Not applicable - no technology involved", 5)
-        ],
-        "help": "Technology training needs frequent updates to remain useful"
-    },
-    {
-        "id": "learner_feedback",
-        "question": "What kind of feedback do you receive from learners about the content?",
-        "type": "single_choice",
-        "options": [
-            ("Consistently positive and engaged", 5),
-            ("Mostly positive with minor suggestions", 4),
-            ("Mixed feedback - some find it helpful", 3),
-            ("Frequent complaints about relevance", 2),
-            ("Learners find it outdated or unhelpful", 1)
-        ],
-        "help": "Learner feedback is a key indicator of content effectiveness"
-    },
-    {
-        "id": "completion_rates",
-        "question": "How are your training completion rates?",
-        "type": "single_choice",
-        "options": [
-            ("80%+ completion rate", 5),
-            ("60-79% completion rate", 4),
-            ("40-59% completion rate", 3),
-            ("20-39% completion rate", 2),
-            ("Below 20% completion rate", 1),
-            ("Don't track completion rates", 2)
-        ],
-        "help": "Low completion rates often indicate content problems"
-    },
-    {
-        "id": "performance_impact",
-        "question": "Can you measure improved job performance after training?",
-        "type": "single_choice",
-        "options": [
-            ("Clear performance improvements measured", 5),
-            ("Some improvements observed", 4),
-            ("Minimal or unclear impact", 3),
-            ("No measurable improvement", 2),
-            ("Performance may have declined", 1)
-        ],
-        "help": "Effective training should lead to measurable performance gains"
-    },
-    {
-        "id": "content_format",
-        "question": "How well does your content format match current learner preferences?",
-        "type": "single_choice",
-        "options": [
-            ("Perfect match - modern, engaging format", 5),
-            ("Good match with minor format updates needed", 4),
-            ("Adequate but could be more engaging", 3),
-            ("Format feels somewhat outdated", 2),
-            ("Very outdated format (old videos, static PDFs)", 1)
-        ],
-        "help": "Learning preferences evolve - mobile, interactive, bite-sized content is preferred"
-    },
-    {
-        "id": "compliance_requirements",
-        "question": "Are there new compliance or regulatory requirements affecting your training?",
-        "type": "single_choice",
-        "options": [
-            ("No new requirements", 5),
-            ("Minor updates needed for compliance", 4),
-            ("Some new requirements to incorporate", 3),
-            ("Significant compliance changes needed", 2),
-            ("Major regulatory overhaul required", 1),
-            ("Not applicable - no compliance requirements", 5)
-        ],
-        "help": "Regulatory changes can make training content non-compliant"
-    },
-    {
-        "id": "accessibility",
-        "question": "Does your content meet current accessibility standards?",
-        "type": "single_choice",
-        "options": [
-            ("Fully accessible and compliant", 5),
-            ("Mostly accessible with minor gaps", 4),
-            ("Some accessibility features missing", 3),
-            ("Limited accessibility support", 2),
-            ("Not designed with accessibility in mind", 1)
-        ],
-        "help": "Accessibility standards have evolved significantly in recent years"
-    },
-    {
-        "id": "competitive_benchmark",
-        "question": "How does your training content compare to industry standards or competitors?",
-        "type": "single_choice",
-        "options": [
-            ("Industry-leading quality and innovation", 5),
-            ("Above average compared to competitors", 4),
-            ("On par with industry standards", 3),
-            ("Below average - competitors have better content", 2),
-            ("Significantly behind industry standards", 1)
-        ],
-        "help": "Staying competitive requires keeping up with industry training standards"
+# Helper functions
+def calculate_estimated_duration(delivery_method, content_depth, audience_size):
+    """Calculate estimated course duration based on inputs"""
+    base_hours = {
+        "In-person workshop": 8,
+        "Virtual live session": 4,
+        "Self-paced online": 6,
+        "Blended learning": 12,
+        "Microlearning series": 2,
+        "On-the-job training": 16
     }
-]
-
-def calculate_assessment_score(answers):
-    """Calculate the overall assessment score and determine status"""
-    total_score = sum(answers.values())
-    max_possible = len(answers) * 5
-    percentage = (total_score / max_possible) * 100
-    
-    # Determine status based on percentage
-    if percentage >= 85:
-        status = "Still Sharp"
-        status_class = "status-excellent"
-        status_emoji = "🌟"
-        status_color = "#28a745"
-    elif percentage >= 70:
-        status = "Minor Tune-Up"
-        status_class = "status-good"
-        status_emoji = "✅"
-        status_color = "#ffc107"
-    elif percentage >= 50:
-        status = "Needs Refresh"
-        status_class = "status-needs-attention"
-        status_emoji = "⚠️"
-        status_color = "#fd7e14"
-    else:
-        status = "Critical Update"
-        status_class = "status-critical"
-        status_emoji = "🚨"
-        status_color = "#dc3545"
-    
-    return {
-        "score": total_score,
-        "percentage": percentage,
-        "status": status,
-        "status_class": status_class,
-        "status_emoji": status_emoji,
-        "status_color": status_color,
-        "max_possible": max_possible
+    
+    depth_multiplier = {
+        "Basic overview": 0.7,
+        "Intermediate depth": 1.0,
+        "Advanced/comprehensive": 1.5,
+        "Expert level": 2.0
     }
+    
+    size_factor = 1.0
+    if audience_size == "Large group (20+)":
+        size_factor = 1.2
+    elif audience_size == "Small team (5-15)":
+        size_factor = 0.9
+    
+    estimated = base_hours.get(delivery_method, 6) * depth_multiplier.get(content_depth, 1.0) * size_factor
+    return max(1, round(estimated))
 
-def generate_recommendations(answers, results):
-    """Generate personalized recommendations based on assessment results"""
-    recommendations = []
+def generate_learning_objectives(course_topic, target_audience, goals):
+    """Generate sample learning objectives based on inputs"""
+    objectives = []
     
-    # Analyze specific areas that need attention
-    problem_areas = []
-    
-    # Check content age
-    if answers.get("content_age", 5) <= 2:
-        problem_areas.append("content_age")
-        recommendations.append({
-            "title": "Update Content Immediately",
-            "description": "Your content is significantly outdated. Plan a comprehensive content refresh within the next 2-3 months.",
-            "priority": "high",
-            "action_items": [
-                "Audit all training materials for accuracy",
-                "Research current industry best practices",
-                "Create a content update timeline",
-                "Consider outsourcing content development if needed"
-            ]
-        })
+    # Create objectives based on common learning patterns
+    action_verbs = ["identify", "analyze", "implement", "evaluate", "create", "demonstrate", "apply", "compare"]
     
-    # Check technology relevance
-    if answers.get("technology_updates", 5) <= 2:
-        problem_areas.append("technology")
-        recommendations.append({
-            "title": "Technology Update Required",
-            "description": "Your technology training is using outdated versions that may confuse learners.",
-            "priority": "high",
-            "action_items": [
-                "Update all software versions in training",
-                "Create version-specific training modules",
-                "Establish regular technology review schedule"
-            ]
-        })
+    if goals:
+        goal_keywords = goals.lower().split()
+        if any(word in goal_keywords for word in ["skill", "skills", "ability", "practice"]):
+            objectives.append(f"Demonstrate practical {course_topic.lower()} skills relevant to {target_audience.lower()}")
+        if any(word in goal_keywords for word in ["knowledge", "understand", "learn", "know"]):
+            objectives.append(f"Analyze key concepts and principles of {course_topic.lower()}")
+        if any(word in goal_keywords for word in ["improve", "enhance", "better", "increase"]):
+            objectives.append(f"Implement strategies to improve {course_topic.lower()} outcomes")
+        if any(word in goal_keywords for word in ["solve", "problem", "challenge", "issue"]):
+            objectives.append(f"Evaluate and solve common {course_topic.lower()} challenges")
     
-    # Check learner engagement
-    if answers.get("learner_feedback", 5) <= 3 or answers.get("completion_rates", 5) <= 3:
-        problem_areas.append("engagement")
-        recommendations.append({
-            "title": "Improve Learner Engagement",
-            "description": "Low engagement suggests content format or relevance issues.",
-            "priority": "medium",
-            "action_items": [
-                "Survey learners for specific feedback",
-                "Consider interactive content formats",
-                "Break content into smaller, digestible modules",
-                "Add gamification elements"
-            ]
-        })
+    # Add default objectives if none generated
+    if not objectives:
+        objectives = [
+            f"Apply {course_topic.lower()} best practices in real-world scenarios",
+            f"Identify key success factors for {course_topic.lower()}",
+            f"Create actionable plans for implementing {course_topic.lower()} strategies"
+        ]
     
-    # Check format modernization
-    if answers.get("content_format", 5) <= 3:
-        problem_areas.append("format")
-        recommendations.append({
-            "title": "Modernize Content Format",
-            "description": "Update your content format to match current learner preferences.",
-            "priority": "medium",
-            "action_items": [
-                "Convert static content to interactive formats",
-                "Optimize for mobile devices",
-                "Add video and multimedia elements",
-                "Create bite-sized learning modules"
-            ]
-        })
+    return objectives[:4]  # Limit to 4 objectives
+
+def generate_course_modules(course_topic, objectives, delivery_method):
+    """Generate suggested course modules"""
+    modules = []
     
-    # Check compliance
-    if answers.get("compliance_requirements", 5) <= 3:
-        problem_areas.append("compliance")
-        recommendations.append({
-            "title": "Address Compliance Gaps",
-            "description": "New regulatory requirements need to be incorporated into your training.",
-            "priority": "high",
-            "action_items": [
-                "Review current compliance requirements",
-                "Update content to meet new standards",
-                "Document compliance coverage",
-                "Schedule regular compliance reviews"
-            ]
-        })
+    # Always start with introduction
+    modules.append({
+        "title": f"Introduction to {course_topic}",
+        "duration": "30-45 minutes",
+        "content": ["Course overview", "Learning objectives", "Participant introductions", "Setting expectations"]
+    })
     
-    # Check accessibility
-    if answers.get("accessibility", 5) <= 3:
-        problem_areas.append("accessibility")
-        recommendations.append({
-            "title": "Enhance Accessibility",
-            "description": "Improve accessibility to ensure all learners can effectively use your content.",
-            "priority": "medium",
-            "action_items": [
-                "Conduct accessibility audit",
-                "Add captions to videos",
-                "Ensure screen reader compatibility",
-                "Provide alternative formats"
-            ]
+    # Generate core modules based on objectives
+    for i, objective in enumerate(objectives, 1):
+        module_title = f"Module {i}: {objective.split(' ', 1)[1].title()}"
+        modules.append({
+            "title": module_title,
+            "duration": "60-90 minutes",
+            "content": ["Theory and concepts", "Practical exercises", "Case studies", "Group discussions"]
         })
     
-    # Performance tracking
-    if answers.get("performance_impact", 5) <= 3:
-        recommendations.append({
-            "title": "Implement Performance Tracking",
-            "description": "Establish metrics to measure training effectiveness and ROI.",
-            "priority": "low",
-            "action_items": [
-                "Define success metrics",
-                "Implement tracking systems",
-                "Conduct pre/post assessments",
-                "Regular performance reviews"
-            ]
+    # Add application/wrap-up module
+    if delivery_method in ["In-person workshop", "Virtual live session", "Blended learning"]:
+        modules.append({
+            "title": "Application & Action Planning",
+            "duration": "45-60 minutes",
+            "content": ["Real-world application", "Action planning", "Next steps", "Resources and support"]
         })
     
-    # If no major issues, provide maintenance recommendations
-    if results["percentage"] >= 70:
-        recommendations.append({
-            "title": "Maintain Content Excellence",
-            "description": "Your content is in good shape! Focus on continuous improvement.",
-            "priority": "low",
-            "action_items": [
-                "Schedule quarterly content reviews",
-                "Stay updated with industry trends",
-                "Gather regular learner feedback",
-                "Plan incremental improvements"
-            ]
-        })
+    return modules
+
+def calculate_readiness_score(inputs):
+    """Calculate a readiness score based on how complete the inputs are"""
+    score = 0
+    max_score = 100
+    
+    # Core requirements (60 points)
+    if inputs.get('course_topic'): score += 15
+    if inputs.get('target_audience'): score += 15
+    if inputs.get('learning_goals'): score += 15
+    if inputs.get('delivery_method'): score += 15
+    
+    # Additional details (40 points)
+    if inputs.get('available_content'): score += 10
+    if inputs.get('subject_matter_experts'): score += 10
+    if inputs.get('success_metrics'): score += 10
+    if inputs.get('timeline'): score += 5
+    if inputs.get('budget_range'): score += 5
     
-    return recommendations, problem_areas
+    return min(score, max_score)
+
+def generate_recommendations(inputs, readiness_score):
+    """Generate personalized recommendations"""
+    recommendations = []
+    
+    if readiness_score < 60:
+        recommendations.append("🎯 **Priority**: Define clearer learning objectives and success metrics to strengthen your course foundation.")
+    
+    if not inputs.get('subject_matter_experts'):
+        recommendations.append("👥 **Expert Input**: Consider engaging subject matter experts early to ensure content accuracy and relevance.")
+    
+    if inputs.get('delivery_method') == 'Self-paced online' and not inputs.get('available_content'):
+        recommendations.append("📋 **Content Strategy**: Self-paced courses require substantial pre-existing content. Plan for content creation resources.")
+    
+    if inputs.get('target_audience') and 'manager' in inputs.get('target_audience', '').lower():
+        recommendations.append("⚡ **Manager Focus**: Consider shorter, action-oriented modules that respect managers' time constraints.")
+    
+    if inputs.get('delivery_method') == 'Microlearning series':
+        recommendations.append("📱 **Microlearning Tips**: Break content into 5-10 minute digestible chunks with clear takeaways.")
+    
+    if readiness_score >= 80:
+        recommendations.append("🚀 **Ready to Launch**: Your course outline is well-developed! Consider piloting with a small group first.")
+    
+    return recommendations
 
 # Main content
-if not st.session_state["assessment_complete"]:
-    # Assessment questionnaire
-    col1, col2 = st.columns([2, 1])
+col1, col2 = st.columns([1, 1])
+
+with col1:
+    st.markdown('<div class="custom-subheader">Course Planning Inputs</div>', unsafe_allow_html=True)
     
-    with col1:
-        # Progress bar
-        progress = (st.session_state["current_question"]) / len(ASSESSMENT_QUESTIONS)
-        st.markdown(f"""
-        <div class="progress-bar">
-            <div class="progress-fill" style="width: {progress * 100}%"></div>
-        </div>
-        <p style="text-align: center; margin-bottom: 20px;">Question {st.session_state["current_question"] + 1} of {len(ASSESSMENT_QUESTIONS)}</p>
-        """, unsafe_allow_html=True)
+    # Core course information
+    st.markdown("**📋 Core Course Information**")
+    
+    course_topic = st.text_input(
+        "Course Topic/Subject",
+        placeholder="e.g., Leadership Development, Data Analysis, Customer Service",
+        help="What is the main subject or skill your course will cover?"
+    )
+    
+    target_audience = st.text_input(
+        "Target Audience",
+        placeholder="e.g., New managers, Sales team, Customer support representatives",
+        help="Who are the learners? Be specific about their role, experience level, etc."
+    )
+    
+    learning_goals = st.text_area(
+        "Learning Goals & Objectives",
+        placeholder="e.g., Improve team communication skills, reduce customer complaints by 20%, increase productivity",
+        height=100,
+        help="What should participants be able to do after completing the course?"
+    )
+    
+    col_d1, col_d2 = st.columns(2)
+    with col_d1:
+        delivery_method = st.selectbox(
+            "Preferred Delivery Method",
+            ["In-person workshop", "Virtual live session", "Self-paced online", "Blended learning", "Microlearning series", "On-the-job training"],
+            help="How do you want to deliver this training?"
+        )
+    
+    with col_d2:
+        content_depth = st.selectbox(
+            "Content Depth",
+            ["Basic overview", "Intermediate depth", "Advanced/comprehensive", "Expert level"],
+            index=1,
+            help="How deep should the content go?"
+        )
+    
+    # Additional details in expandable section
+    with st.expander("📊 Additional Planning Details", expanded=False):
+        st.markdown('<div class="settings-section">', unsafe_allow_html=True)
         
-        # Current question
-        if st.session_state["current_question"] < len(ASSESSMENT_QUESTIONS):
-            current_q = ASSESSMENT_QUESTIONS[st.session_state["current_question"]]
-            
-            st.markdown(f'<div class="question-card">', unsafe_allow_html=True)
-            st.markdown(f"""
-            <div style="display: flex; align-items: center; margin-bottom: 15px;">
-                <span class="question-number">{st.session_state["current_question"] + 1}</span>
-                <h3 style="margin: 0;">{current_q["question"]}</h3>
-            </div>
-            """, unsafe_allow_html=True)
+        col_a1, col_a2 = st.columns(2)
+        with col_a1:
+            audience_size = st.selectbox(
+                "Audience Size",
+                ["Individual (1-on-1)", "Small team (5-15)", "Medium group (15-30)", "Large group (20+)"],
+                index=1
+            )
             
-            # Question options
-            if current_q["type"] == "single_choice":
-                answer = st.radio(
-                    "Select your answer:",
-                    options=[option[0] for option in current_q["options"]],
-                    key=f"question_{current_q['id']}",
-                    help=current_q.get("help", "")
-                )
-                
-                # Find the score for the selected answer
-                selected_score = None
-                for option_text, score in current_q["options"]:
-                    if option_text == answer:
-                        selected_score = score
-                        break
-                
-                if selected_score is not None:
-                    st.session_state["answers"][current_q["id"]] = selected_score
-            
-            st.markdown('</div>', unsafe_allow_html=True)
-            
-            # Navigation buttons
-            col_prev, col_next = st.columns([1, 1])
-            
-            with col_prev:
-                if st.session_state["current_question"] > 0:
-                    if st.button("⬅️ Previous", use_container_width=True):
-                        st.session_state["current_question"] -= 1
-                        st.rerun()
+            timeline = st.selectbox(
+                "Development Timeline",
+                ["Rush (1-2 weeks)", "Standard (1-2 months)", "Extended (3-6 months)", "Long-term (6+ months)"],
+                index=1
+            )
+        
+        with col_a2:
+            budget_range = st.selectbox(
+                "Budget Range",
+                ["Minimal budget", "Small budget ($1K-5K)", "Medium budget ($5K-20K)", "Large budget ($20K+)", "Not specified"],
+                index=4
+            )
             
-            with col_next:
-                if st.session_state["current_question"] < len(ASSESSMENT_QUESTIONS) - 1:
-                    if st.button("Next ➡️", use_container_width=True):
-                        st.session_state["current_question"] += 1
-                        st.rerun()
-                else:
-                    if st.button("📊 Get My Results", use_container_width=True):
-                        st.session_state["assessment_complete"] = True
-                        st.session_state["assessment_results"] = calculate_assessment_score(st.session_state["answers"])
-                        st.rerun()
-    
-    with col2:
-        st.markdown('<div class="custom-subheader">Assessment Overview</div>', unsafe_allow_html=True)
+            priority_level = st.selectbox(
+                "Priority Level",
+                ["Low priority", "Medium priority", "High priority", "Critical/urgent"],
+                index=2
+            )
         
-        # Show progress stats
-        answered = len(st.session_state["answers"])
-        st.markdown(f"""
-        <div class="stats-container">
-            <div class="stat-item">
-                <div class="stat-number">{answered}</div>
-                <div class="stat-label">Answered</div>
-            </div>
-            <div class="stat-item">
-                <div class="stat-number">{len(ASSESSMENT_QUESTIONS) - answered}</div>
-                <div class="stat-label">Remaining</div>
-            </div>
-        </div>
-        """, unsafe_allow_html=True)
+        available_content = st.text_area(
+            "Available Content & Resources",
+            placeholder="e.g., Existing presentations, documentation, videos, previous training materials",
+            height=75,
+            help="What materials do you already have that could be used or adapted?"
+        )
+        
+        subject_matter_experts = st.text_input(
+            "Subject Matter Experts Available",
+            placeholder="e.g., John Smith (Sales Director), external consultant, internal team leads",
+            help="Who can provide expertise and content validation?"
+        )
+        
+        success_metrics = st.text_area(
+            "Success Metrics & Evaluation",
+            placeholder="e.g., Participant satisfaction scores, skill assessments, behavior change metrics, business impact",
+            height=75,
+            help="How will you measure if the training was successful?"
+        )
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Example scenarios for inspiration
+    with st.expander("Need inspiration? View example training scenarios", expanded=False):
+        st.markdown('<div class="examples-section">', unsafe_allow_html=True)
         
-        # Assessment categories
-        st.markdown("**Assessment Categories:**")
-        categories = [
-            "📅 Content Age & Relevance",
-            "🏭 Industry & Technology Changes", 
-            "👥 Learner Engagement & Feedback",
-            "📈 Performance & Compliance",
-            "♿ Accessibility & Format"
+        example_scenarios = [
+            {
+                "title": "New Manager Leadership Program",
+                "topic": "Leadership Fundamentals",
+                "audience": "Newly promoted managers",
+                "goals": "Develop core leadership skills, improve team management, increase employee engagement scores by 15%"
+            },
+            {
+                "title": "Customer Service Excellence",
+                "topic": "Advanced Customer Service Skills",
+                "audience": "Customer support representatives",
+                "goals": "Reduce customer complaints by 25%, improve satisfaction ratings, handle difficult situations confidently"
+            },
+            {
+                "title": "Data-Driven Decision Making",
+                "topic": "Business Analytics and Data Interpretation",
+                "audience": "Department managers and analysts",
+                "goals": "Make better decisions using data, create meaningful reports, identify key performance indicators"
+            },
+            {
+                "title": "Remote Team Management",
+                "topic": "Managing Virtual Teams",
+                "audience": "Team leaders and managers",
+                "goals": "Improve virtual team productivity, enhance remote communication, maintain team culture"
+            }
         ]
         
-        for category in categories:
-            st.markdown(f"• {category}")
+        for i, example in enumerate(example_scenarios):
+            if st.button(f"Use Example: {example['title']}", key=f"example_{i}"):
+                st.session_state["example_data"] = example
+                st.rerun()
         
-        # Tips
-        with st.expander("💡 Assessment Tips"):
-            st.markdown("""
-            **For Best Results:**
-            - Answer honestly based on your current situation
-            - Consider gathering learner feedback before assessment
-            - Think about recent industry or regulatory changes
-            - Review your training analytics if available
-            - Consider both technical and content aspects
-            """)
-
-else:
-    # Results display
-    results = st.session_state["assessment_results"]
-    recommendations, problem_areas = generate_recommendations(st.session_state["answers"], results)
-    
-    # Status card
-    st.markdown(f"""
-    <div class="status-card {results['status_class']}">
-        <div class="status-score" style="color: {results['status_color']}">
-            {results['status_emoji']} {results['percentage']:.0f}%
-        </div>
-        <div class="status-title" style="color: {results['status_color']}">
-            {results['status']}
-        </div>
-        <div class="status-description">
-            You scored {results['score']} out of {results['max_possible']} points
-        </div>
-    </div>
-    """, unsafe_allow_html=True)
-    
-    # Status-specific messages
-    status_messages = {
-        "Still Sharp": "Excellent! Your training content is current and effective. Focus on maintenance and continuous improvement.",
-        "Minor Tune-Up": "Good foundation! Your content is mostly current but could benefit from some updates to stay competitive.",
-        "Needs Refresh": "Time for updates! Your content has some outdated elements that are impacting effectiveness.",
-        "Critical Update": "Immediate action needed! Your content requires significant updates to remain valuable and relevant."
-    }
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Apply example data if selected
+    if "example_data" in st.session_state:
+        example = st.session_state["example_data"]
+        course_topic = example["topic"]
+        target_audience = example["audience"]
+        learning_goals = example["goals"]
+        del st.session_state["example_data"]
     
-    st.success(status_messages[results['status']])
+    # Generate outline button
+    generate_button = st.button(
+        "📚 Generate Course Outline",
+        disabled=not course_topic or not target_audience or not learning_goals,
+        use_container_width=True
+    )
+    
+    if not course_topic or not target_audience or not learning_goals:
+        st.info("Please fill in the core course information (topic, audience, and goals) to generate an outline")
+
+# Display generated outline
+with col2:
+    st.markdown('<div class="custom-subheader">Generated Course Outline</div>', unsafe_allow_html=True)
     
-    # Detailed recommendations
-    col1, col2 = st.columns([1, 1])
+    if generate_button and course_topic and target_audience and learning_goals:
+        with st.spinner("Creating your course outline..."):
+            # Simulate processing time
+            time.sleep(1)
+            
+            # Collect all inputs
+            course_inputs = {
+                'course_topic': course_topic,
+                'target_audience': target_audience,
+                'learning_goals': learning_goals,
+                'delivery_method': delivery_method,
+                'content_depth': content_depth,
+                'audience_size': audience_size if 'audience_size' in locals() else 'Medium group (15-30)',
+                'timeline': timeline if 'timeline' in locals() else 'Standard (1-2 months)',
+                'budget_range': budget_range if 'budget_range' in locals() else 'Not specified',
+                'priority_level': priority_level if 'priority_level' in locals() else 'Medium priority',
+                'available_content': available_content if 'available_content' in locals() else '',
+                'subject_matter_experts': subject_matter_experts if 'subject_matter_experts' in locals() else '',
+                'success_metrics': success_metrics if 'success_metrics' in locals() else ''
+            }
+            
+            # Generate course outline components
+            estimated_duration = calculate_estimated_duration(delivery_method, content_depth, course_inputs['audience_size'])
+            learning_objectives = generate_learning_objectives(course_topic, target_audience, learning_goals)
+            course_modules = generate_course_modules(course_topic, learning_objectives, delivery_method)
+            readiness_score = calculate_readiness_score(course_inputs)
+            recommendations = generate_recommendations(course_inputs, readiness_score)
+            
+            outline_data = {
+                'inputs': course_inputs,
+                'estimated_duration': estimated_duration,
+                'learning_objectives': learning_objectives,
+                'course_modules': course_modules,
+                'readiness_score': readiness_score,
+                'recommendations': recommendations,
+                'generated_date': datetime.now().strftime("%Y-%m-%d %H:%M")
+            }
+            
+            st.session_state["generated_outline"] = outline_data
+            
+            # Add to history
+            if outline_data not in st.session_state["course_history"]:
+                st.session_state["course_history"].insert(0, outline_data)
+                st.session_state["course_history"] = st.session_state["course_history"][:5]  # Keep last 5
+            
+            st.success("✅ Course outline generated successfully!")
     
-    with col1:
-        st.markdown('<div class="custom-subheader">📋 Your Action Plan</div>', unsafe_allow_html=True)
+    if st.session_state["generated_outline"] is not None:
+        outline = st.session_state["generated_outline"]
         
-        # Priority recommendations first
-        high_priority = [r for r in recommendations if r["priority"] == "high"]
-        medium_priority = [r for r in recommendations if r["priority"] == "medium"]
-        low_priority = [r for r in recommendations if r["priority"] == "low"]
+        st.markdown('<div class="generated-outline">', unsafe_allow_html=True)
         
-        for priority_group, title in [(high_priority, "🚨 High Priority"), (medium_priority, "⚠️ Medium Priority"), (low_priority, "💡 Low Priority")]:
-            if priority_group:
-                st.markdown(f"**{title}**")
-                for rec in priority_group:
-                    st.markdown(f'<div class="recommendation-card priority-{rec["priority"]}">', unsafe_allow_html=True)
-                    st.markdown(f'<div class="recommendation-title">{rec["title"]}</div>', unsafe_allow_html=True)
-                    st.markdown(f'<p>{rec["description"]}</p>', unsafe_allow_html=True)
-                    
-                    if rec["action_items"]:
-                        st.markdown("**Action Items:**")
-                        for item in rec["action_items"]:
-                            st.markdown(f"• {item}")
-                    
-                    st.markdown('</div>', unsafe_allow_html=True)
-    
-    with col2:
-        st.markdown('<div class="custom-subheader">📊 Detailed Breakdown</div>', unsafe_allow_html=True)
+        # Course Overview Section
+        st.markdown("### 📋 Course Overview")
+        st.markdown(f"**Course Title:** {outline['inputs']['course_topic']}")
+        st.markdown(f"**Target Audience:** {outline['inputs']['target_audience']}")
+        st.markdown(f"**Delivery Method:** {outline['inputs']['delivery_method']}")
+        st.markdown(f"**Estimated Duration:** {outline['estimated_duration']} hours")
         
-        # Score breakdown by category
-        category_scores = {}
-        for q in ASSESSMENT_QUESTIONS:
-            score = st.session_state["answers"].get(q["id"], 0)
-            category_scores[q["question"]] = (score, 5)
+        # Readiness Score
+        score_color = "green" if outline['readiness_score'] >= 80 else "orange" if outline['readiness_score'] >= 60 else "red"
+        st.markdown(f"""
+        <div class="success-indicator">
+            <strong>Course Readiness Score: <span style="color: {score_color};">{outline['readiness_score']}/100</span></strong>
+            <br><small>Based on completeness of planning inputs</small>
+        </div>
+        """, unsafe_allow_html=True)
         
-        # Show problem areas
-        if problem_areas:
-            st.markdown("**Areas Needing Attention:**")
-            area_labels = {
-                "content_age": "📅 Content Age",
-                "technology": "💻 Technology Currency",
-                "engagement": "👥 Learner Engagement", 
-                "format": "🎨 Content Format",
-                "compliance": "📋 Compliance",
-                "accessibility": "♿ Accessibility"
-            }
-            
-            for area in problem_areas:
-                if area in area_labels:
-                    st.markdown(f"• {area_labels[area]}")
+        # Learning Objectives
+        st.markdown("### 🎯 Learning Objectives")
+        st.markdown("Upon completion, participants will be able to:")
+        for i, objective in enumerate(outline['learning_objectives'], 1):
+            st.markdown(f"{i}. {objective.capitalize()}")
         
-        # Timeline estimate
-        st.markdown("**Estimated Timeline:**")
-        if results['percentage'] >= 85:
-            timeline = "1-2 months for maintenance"
-        elif results['percentage'] >= 70:
-            timeline = "2-4 months for updates"
-        elif results['percentage'] >= 50:
-            timeline = "3-6 months for refresh"
-        else:
-            timeline = "6+ months for overhaul"
+        # Course Modules
+        st.markdown("### 📚 Proposed Course Structure")
+        for i, module in enumerate(outline['course_modules'], 1):
+            st.markdown(f"""
+            <div class="outline-section">
+                <strong>{module['title']}</strong> ({module['duration']})
+                <ul>
+                    {"".join([f"<li>{item}</li>" for item in module['content']])}
+                </ul>
+            </div>
+            """, unsafe_allow_html=True)
         
-        st.info(f"⏱️ {timeline}")
+        # Success Metrics
+        if outline['inputs']['success_metrics']:
+            st.markdown("### 📊 Success Metrics")
+            st.markdown(outline['inputs']['success_metrics'])
         
-        # Export options
-        st.markdown("**Export Results:**")
+        # Recommendations
+        if outline['recommendations']:
+            st.markdown("### 💡 Recommendations & Next Steps")
+            for rec in outline['recommendations']:
+                st.markdown(f"""
+                <div class="recommendation">
+                    {rec}
+                </div>
+                """, unsafe_allow_html=True)
         
-        # Generate report data
-        report_data = {
-            "assessment_date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            "overall_score": results,
-            "answers": st.session_state["answers"],
-            "recommendations": recommendations,
-            "problem_areas": problem_areas
-        }
+        st.markdown('</div>', unsafe_allow_html=True)
         
-        report_json = json.dumps(report_data, indent=2)
+        # Action buttons
+        col_b1, col_b2 = st.columns(2)
         
-        st.download_button(
-            label="📊 Download Full Report",
-            data=report_json,
-            file_name=f"training_assessment_{int(time.time())}.json",
-            mime="application/json",
-            use_container_width=True
-        )
-    
-    # Action buttons
-    st.markdown("---")
-    col_b1, col_b2, col_b3 = st.columns([1, 1, 1])
-    
-    with col_b1:
-        if st.button("🔄 Take Assessment Again", use_container_width=True):
-            # Reset session state
-            st.session_state["assessment_complete"] = False
-            st.session_state["current_question"] = 0
-            st.session_state["answers"] = {}
-            st.session_state["assessment_results"] = None
-            st.rerun()
-    
-    with col_b2:
-        if st.button("📝 View Question Summary", use_container_width=True):
-            with st.expander("Question & Answer Summary", expanded=True):
-                for i, q in enumerate(ASSESSMENT_QUESTIONS):
-                    answer_score = st.session_state["answers"].get(q["id"], 0)
-                    # Find the answer text
-                    answer_text = "Not answered"
-                    for option_text, score in q["options"]:
-                        if score == answer_score:
-                            answer_text = option_text
-                            break
+        with col_b1:
+            # Download as JSON
+            outline_json = json.dumps(outline, indent=2)
+            st.download_button(
+                label="💾 Download Outline",
+                data=outline_json,
+                file_name=f"course_outline_{int(time.time())}.json",
+                mime="application/json",
+                use_container_width=True
+            )
+        
+        with col_b2:
+            # Regenerate button
+            if st.button("🔄 Refine Outline", use_container_width=True):
+                with st.spinner("Refining course outline..."):
+                    time.sleep(1)
+                    # Regenerate with slight variations
+                    learning_objectives = generate_learning_objectives(course_topic, target_audience, learning_goals)
+                    course_modules = generate_course_modules(course_topic, learning_objectives, delivery_method)
                     
-                    st.markdown(f"**Q{i+1}: {q['question']}**")
-                    st.markdown(f"*Answer: {answer_text}* (Score: {answer_score}/5)")
-                    st.markdown("---")
-    
-    with col_b3:
-        # Placeholder for future feature
-        st.button("💬 Get Expert Consultation", disabled=True, use_container_width=True, help="Coming soon - connect with training experts")
+                    outline['learning_objectives'] = learning_objectives
+                    outline['course_modules'] = course_modules
+                    st.session_state["generated_outline"] = outline
+                    st.success("✅ Outline refined!")
+                    st.rerun()
+        
+        # Partnership CTA
+        st.markdown("""
+        <div class="partnership-cta">
+            <h3>🚀 Ready to Bring Your Course to Life?</h3>
+            <p>This outline is just the beginning! Partner with our team to transform your vision into a comprehensive, engaging training program that delivers real results.</p>
+            <p><strong>Next Steps:</strong> Content development • Instructional design • Learning technology • Delivery support</p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+    else:
+        # Placeholder
+        st.markdown("""
+        <div class="placeholder-area">
+            <h3>📚 Your Course Outline Will Appear Here</h3>
+            <p>Fill in the course planning details and click 'Generate Course Outline' to see your structured training plan.</p>
+            <br>
+            <p><strong>Your outline will include:</strong></p>
+            <p>✅ Learning objectives<br>
+            ✅ Course structure & modules<br>
+            ✅ Estimated duration<br>
+            ✅ Readiness assessment<br>
+            ✅ Personalized recommendations</p>
+        </div>
+        """, unsafe_allow_html=True)
 
 # Footer
 st.markdown("""
 <div class="footnote">
-    <p><strong>Disclaimer:</strong> This assessment provides general guidance based on common training best practices. Results may vary based on your specific context, industry, and organizational needs. Consider consulting with training professionals for detailed content strategy.</p>
-    <p><strong>Pro Tip:</strong> Save your results and retake this assessment quarterly to track your training content health over time!</p>
+    <p><strong>About this tool:</strong> The Training Course Outline Generator helps L&D professionals structure their training ideas into actionable plans. Generated outlines provide a foundation for course development and can be customized based on your specific organizational needs.</p>
 </div>
 """, unsafe_allow_html=True)