#!/usr/bin/env python3
"""
Demo script for Task Manager MCP Servers

This script demonstrates the key functionality of both MCP servers
without requiring Claude Desktop integration.
"""

import asyncio
import os
import sys
from pathlib import Path
from datetime import datetime, timedelta
from unittest.mock import Mock

# Add the project root to Python path
project_root = Path(__file__).parent.parent
sys.path.insert(0, str(project_root))

from shared.models import Task, HumanResource, AgentResource, TaskStatus, TaskPriority


def create_mock_context():
    """Create a mock context for demonstration"""
    context = Mock()
    context.request_context = Mock()
    context.request_context.lifespan_context = Mock()
    
    # Mock app context with sample data
    app_ctx = Mock()
    app_ctx.tasks = {}
    app_ctx.projects = {}
    app_ctx.reminders = {}
    app_ctx.resources = {
        "human_001": HumanResource(
            id="human_001",
            name="Alice Johnson",
            skills=["project_management", "requirements_analysis", "documentation"],
            load=0.3,
            cost_per_hour=85.0,
            status="available"
        ),
        "human_002": HumanResource(
            id="human_002",
            name="Bob Smith",
            skills=["python", "backend_development", "api_design", "database"],
            load=0.7,
            cost_per_hour=95.0,
            status="available"
        ),
        "agent_001": AgentResource(
            id="agent_001",
            name="Code Generation Agent",
            skills=["code_generation", "unit_testing", "documentation"],
            load=0.2,
            cost_per_task=0.5,
            system_prompt="You are a code generation specialist.",
            status="available"
        )
    }
    app_ctx.assignments = {}
    app_ctx.collaboration_plans = {}
    app_ctx.daily_reports = []
    app_ctx.requirement_agent = None
    app_ctx.task_generation_agent = None
    app_ctx.task_decomposition_agent = None
    app_ctx.dependency_manager = None
    
    context.request_context.lifespan_context = app_ctx
    return context


def demo_task_management():
    """Demonstrate Task Management MCP functionality"""
    print("\n" + "="*60)
    print("🎯 TASK MANAGEMENT MCP DEMO")
    print("="*60)
    
    try:
        from task_management_mcp.server import (
            analyze_task_input, 
            get_schedule_recommendation,
            predict_task_risks,
            create_reminder,
            update_task_progress,
            get_next_task_recommendation
        )
        
        ctx = create_mock_context()
        
        # 1. Analyze task input
        print("\n1. 📝 Analyzing Task Input")
        print("-" * 30)
        
        result = analyze_task_input(
            task_description="Build a complete user authentication system with login, registration, password reset, and email verification",
            ctx=ctx,
            project_id="demo_project",
            due_date=(datetime.now() + timedelta(days=14)).isoformat()
        )
        
        print(f"✅ Analyzed {len(result.tasks)} task(s)")
        print(f"📊 Total estimated time: {result.total_estimated_time} hours")
        print(f"🎯 Priority distribution: {result.priority_distribution}")
        
        # Add the task to context for further demos
        if result.tasks:
            main_task = result.tasks[0]
            ctx.request_context.lifespan_context.tasks[main_task.id] = main_task
            
            # 2. Get schedule recommendation
            print("\n2. 📅 Schedule Recommendation")
            print("-" * 30)
            
            schedule = get_schedule_recommendation(
                ctx=ctx,
                available_hours_per_day=8.0
            )
            
            print(f"📋 Recommended order: {schedule.recommended_order}")
            print(f"🎯 Estimated completion: {schedule.estimated_completion_date.strftime('%Y-%m-%d')}")
            print(f"⚠️ Critical path: {schedule.critical_path}")
            
            # 3. Risk prediction
            print("\n3. ⚠️ Risk Prediction")
            print("-" * 30)
            
            risk_assessment = predict_task_risks(main_task.id, ctx)
            
            print(f"🔥 Risk level: {risk_assessment.risk_level}/5")
            print(f"📈 Probability: {risk_assessment.probability:.1%}")
            print(f"🚨 Risk factors: {', '.join(risk_assessment.risk_factors)}")
            print(f"🛡️ Mitigation strategies: {len(risk_assessment.mitigation_strategies)} suggested")
            
            # 4. Create reminder
            print("\n4. ⏰ Creating Reminder")
            print("-" * 30)
            
            reminder = create_reminder(
                task_id=main_task.id,
                reminder_type="deadline",
                ctx=ctx
            )
            
            print(f"📢 Reminder created: {reminder.message}")
            print(f"⏰ Scheduled for: {reminder.scheduled_time.strftime('%Y-%m-%d %H:%M')}")
            
            # 5. Update progress
            print("\n5. 📈 Progress Update")
            print("-" * 30)
            
            progress_update = update_task_progress(
                task_id=main_task.id,
                progress=0.3,
                ctx=ctx,
                time_spent=2.5,
                notes="Completed initial research and planning"
            )
            
            print(f"✅ Progress updated to {progress_update.progress * 100:.1f}%")
            print(f"⏱️ Time spent: {progress_update.time_spent} hours")
            print(f"📝 Notes: {progress_update.notes}")
            
            # 6. Get next task recommendation
            print("\n6. 🎯 Next Task Recommendation")
            print("-" * 30)
            
            recommendation = get_next_task_recommendation(
                ctx=ctx,
                available_time=4.0
            )
            
            if recommendation.task_id:
                print(f"👍 Recommended task: {recommendation.task_id}")
                print(f"⭐ Score: {recommendation.score:.1f}")
                print(f"💡 Reasoning: {recommendation.reasoning}")
            else:
                print("ℹ️ No suitable tasks found for the available time")
        
        print("\n✅ Task Management MCP demo completed successfully!")
        
    except Exception as e:
        print(f"❌ Task Management MCP demo failed: {e}")
        import traceback
        traceback.print_exc()


def demo_task_assignment():
    """Demonstrate Task Assignment MCP functionality"""
    print("\n" + "="*60)
    print("👥 TASK ASSIGNMENT MCP DEMO")
    print("="*60)
    
    try:
        from task_assignment_mcp.server import (
            decompose_complex_task,
            recommend_task_assignment,
            assign_task_to_resource,
            create_collaboration_plan,
            review_daily_report
        )
        
        ctx = create_mock_context()
        
        # Add a complex task for demonstration
        complex_task = Task(
            id="complex_demo_task",
            name="Build Full-Stack E-commerce Platform",
            description="Complete e-commerce solution with frontend, backend, payment integration, and admin panel",
            time_cost=40.0,
            priority=TaskPriority.HIGH,
            project_id="ecommerce_project"
        )
        ctx.request_context.lifespan_context.tasks[complex_task.id] = complex_task
        
        # 1. Task decomposition
        print("\n1. 🔧 Task Decomposition")
        print("-" * 30)
        
        decomposition = decompose_complex_task(
            task_id=complex_task.id,
            ctx=ctx,
            target_time_per_subtask=8.0
        )
        
        print(f"📋 Parent task: {decomposition.parent_task_id}")
        print(f"🔨 Generated {len(decomposition.subtasks)} subtasks")
        print(f"⏱️ Total estimated time: {decomposition.estimated_total_time} hours")
        print(f"🧠 Reasoning: {decomposition.decomposition_reasoning}")
        
        # 2. Assignment recommendation
        print("\n2. 🎯 Assignment Recommendation")
        print("-" * 30)
        
        # Create a backend-focused task
        backend_task = Task(
            id="backend_api_task",
            name="Implement REST API endpoints",
            description="Build Python Flask/FastAPI backend with database integration and authentication",
            time_cost=12.0
        )
        ctx.request_context.lifespan_context.tasks[backend_task.id] = backend_task
        
        assignment_rec = recommend_task_assignment(
            task_id=backend_task.id,
            ctx=ctx
        )
        
        print(f"👤 Recommended resource: {assignment_rec.recommended_resource_id}")
        print(f"🏷️ Resource type: {assignment_rec.resource_type}")
        print(f"⭐ Confidence: {assignment_rec.confidence_score:.2f}")
        print(f"💡 Reasoning: {assignment_rec.reasoning}")
        
        # 3. Actual assignment
        print("\n3. ✅ Task Assignment")
        print("-" * 30)
        
        assignment_result = assign_task_to_resource(
            task_id=backend_task.id,
            resource_id=assignment_rec.recommended_resource_id,
            ctx=ctx,
            notes="Assigned based on skill match and availability"
        )
        
        print(f"📋 Task assigned: {assignment_result['task_id']}")
        print(f"👤 To resource: {assignment_result['resource_name']}")
        print(f"📅 Assignment date: {assignment_result['assignment_date']}")
        
        # 4. Collaboration plan
        print("\n4. 🤝 Collaboration Plan")
        print("-" * 30)
        
        collab_plan = create_collaboration_plan(
            task_id=complex_task.id,
            ctx=ctx,
            required_skills=["frontend", "backend", "database", "testing"],
            max_team_size=3
        )
        
        print(f"👥 Team size: {len(collab_plan.team_members)}")
        print(f"🔄 Collaboration type: {collab_plan.collaboration_type}")
        print(f"📋 Coordination strategy: {collab_plan.coordination_strategy}")
        print(f"🎯 Milestones: {len(collab_plan.milestone_schedule)}")
        
        # 5. Daily report review
        print("\n5. 📊 Daily Report Review")
        print("-" * 30)
        
        sample_report = """
        Today I completed the user authentication API endpoints including login, logout, and token refresh.
        I thoroughly tested all endpoints using Postman and wrote comprehensive unit tests with 95% coverage.
        I collaborated with the frontend team to finalize the API contract and helped review their integration code.
        I also optimized the database queries for better performance and documented all the new endpoints.
        Tomorrow I plan to work on the user profile management features.
        """
        
        review = review_daily_report(
            team_member_id="human_002",
            report_content=sample_report,
            ctx=ctx
        )
        
        print(f"👤 Team member: {review.team_member_id}")
        print(f"📈 Productivity score: {review.productivity_score:.1f}/10")
        print(f"🎯 Quality score: {review.quality_score:.1f}/10")
        print(f"🤝 Collaboration score: {review.collaboration_score:.1f}/10")
        print(f"⭐ Overall score: {review.overall_score:.1f}/10")
        print(f"🏆 Achievements: {len(review.achievements)}")
        print(f"📝 Feedback: {review.feedback[:100]}...")
        
        print("\n✅ Task Assignment MCP demo completed successfully!")
        
    except Exception as e:
        print(f"❌ Task Assignment MCP demo failed: {e}")
        import traceback
        traceback.print_exc()


def main():
    """Main demo function"""
    print("🚀 Task Manager MCP Servers - Demo")
    print("=" * 60)
    print("This demo showcases the key functionality of both MCP servers")
    print("without requiring Claude Desktop integration.")
    print()
    
    # Check environment (optional for demo)
    if not os.environ.get("OPENAI_API_KEY"):
        print("⚠️ OPENAI_API_KEY not set - AI features will use fallback implementations")
        print()
    
    try:
        # Run demos
        demo_task_management()
        demo_task_assignment()
        
        print("\n" + "="*60)
        print("🎉 DEMO COMPLETED SUCCESSFULLY!")
        print("="*60)
        print("\nNext steps:")
        print("1. Set up Claude Desktop integration")
        print("2. Configure the MCP servers in claude_desktop_config.json")
        print("3. Start using the servers with Claude Desktop")
        print("\nFor more information, see MCP_README.md")
        
    except KeyboardInterrupt:
        print("\n\n⏹️ Demo interrupted by user")
    except Exception as e:
        print(f"\n\n❌ Demo failed with error: {e}")
        import traceback
        traceback.print_exc()


if __name__ == "__main__":
    main()