#!/usr/bin/env python3
"""
Enhance all agent testing scenarios with functional demonstrations,
comprehensive command testing, and professional completion workflows.
"""

import os
import re
from pathlib import Path

# Scenario enhancements with functional demonstrations
scenario_enhancements = {
    "02-childcare-regulations": {
        "title": "Childcare Center - Regulatory Compliance Intelligence",
        "task": "Build a smart regulatory compliance assistant that instantly answers licensing questions",
        "description": "You're opening a new childcare center and drowning in regulatory requirements from multiple agencies. You'll use FSS-Mini-RAG to create an intelligent compliance system that can instantly answer any licensing, safety, or operational question.",
        "folder": "childcare-compliance-docs",
        "system_name": "Childcare Compliance Intelligence System",
        "commands": [
            'rag-mini search "What is the minimum square footage required per child in play areas?"',
            'rag-mini search "What background check requirements exist for childcare staff?"',
            'rag-mini search "What are the handwashing and sanitation requirements?"',
            'rag-mini search "How many emergency exits are required for a 50-child facility?"',
            'rag-mini search "What staff-to-child ratios are mandated for different age groups?"'
        ],
        "advanced_commands": [
            'rag-mini find-function "safety_checklist"',
            'rag-mini find-class "ComplianceRecord"'
        ],
        "professional_impact": [
            "How much time would this save during licensing preparation?",
            "Could this help ensure full compliance and avoid violations?",
            "What would be the value for training new childcare staff?"
        ]
    },
    
    "03-plant-logistics": {
        "title": "Plant Logistics - Warehouse Intelligence System",
        "task": "Build a smart logistics assistant that optimizes warehouse operations and supply chain efficiency",
        "description": "You're managing a manufacturing plant with supply chain bottlenecks and warehouse inefficiencies. You'll use FSS-Mini-RAG to create an intelligent operations system that can instantly provide optimization strategies and best practices.",
        "folder": "logistics-optimization-docs",
        "system_name": "Warehouse Operations Intelligence System",
        "commands": [
            'rag-mini search "What are the key principles of efficient warehouse layout design?"',
            'rag-mini search "How can Just-In-Time inventory reduce carrying costs?"',
            'rag-mini search "What metrics should be used to measure supply chain performance?"',
            'rag-mini search "How can automation improve warehouse picking accuracy?"',
            'rag-mini search "What strategies reduce supply chain disruption risks?"'
        ],
        "advanced_commands": [
            'rag-mini find-function "inventory_optimization"',
            'rag-mini find-class "SupplyChainMetrics"'
        ],
        "professional_impact": [
            "How much cost savings could these optimizations provide?",
            "Could this help reduce inventory carrying costs and waste?",
            "What would be the value for training logistics coordinators?"
        ]
    },

    "04-financial-compliance": {
        "title": "Financial Services - Regulatory Intelligence Hub",
        "task": "Build a smart financial compliance assistant that navigates complex SEC and FINRA regulations",
        "description": "You're a compliance officer drowning in ever-changing financial regulations. You'll use FSS-Mini-RAG to create an intelligent regulatory system that can instantly answer any compliance question and keep you ahead of regulatory changes.",
        "folder": "financial-regulations-docs", 
        "system_name": "Financial Compliance Intelligence Hub",
        "commands": [
            'rag-mini search "What are the reporting requirements for Form ADV updates?"',
            'rag-mini search "How often must AML policies be reviewed and updated?"',
            'rag-mini search "What cybersecurity measures are required for client data protection?"',
            'rag-mini search "What documentation is required for demonstrating fiduciary duty?"',
            'rag-mini search "What are the penalties for non-compliance with SEC regulations?"'
        ],
        "advanced_commands": [
            'rag-mini find-function "compliance_check"',
            'rag-mini find-class "RegulatoryRequirement"'
        ],
        "professional_impact": [
            "How much time would this save during compliance reviews?",
            "Could this help avoid costly regulatory violations?",
            "What would be the value for training compliance staff?"
        ]
    },

    "05-medical-research": {
        "title": "Medical Research - Clinical Trial Intelligence System",
        "task": "Build a smart clinical research assistant that navigates FDA regulations and GCP guidelines",
        "description": "You're coordinating clinical trials and struggling with complex FDA requirements and GCP guidelines. You'll use FSS-Mini-RAG to create an intelligent research system that can instantly answer any protocol, safety, or regulatory question.",
        "folder": "clinical-research-docs",
        "system_name": "Clinical Trial Intelligence System", 
        "commands": [
            'rag-mini search "What are the FDA requirements for Phase II trial design?"',
            'rag-mini search "How should adverse events be classified and reported?"',
            'rag-mini search "What statistical power calculations are needed for efficacy endpoints?"',
            'rag-mini search "What informed consent elements are required?"',
            'rag-mini search "How should patient eligibility criteria be defined?"'
        ],
        "advanced_commands": [
            'rag-mini find-function "adverse_event_report"',
            'rag-mini find-class "TrialProtocol"'
        ],
        "professional_impact": [
            "How much time would this save during protocol development?",
            "Could this help ensure FDA compliance and patient safety?",
            "What would be the value for training clinical research coordinators?"
        ]
    },

    # Add more scenarios here...
}

def create_functional_instructions(scenario_id, enhancement):
    """Create functional instructions with comprehensive command testing."""
    
    instructions = f"""# Test Scenario {scenario_id.split('-')[0].zfill(2)}: {enhancement['title']}

## 🏢 **Industry Context**: {enhancement['title'].split(' - ')[0]}
**Role**: {get_role_from_title(enhancement['title'])}  
**Task**: {enhancement['task']}

## 📋 **Scenario Description**
{enhancement['description']}

## 🎯 **Your Mission (Completely Autonomous)**

### **Step 1: Setup FSS-Mini-RAG**
1. Read the repository README.md to understand how to install FSS-Mini-RAG
2. Follow the installation instructions for your platform
3. Verify the installation works by running `rag-mini --help`

### **Step 2: Gather Industry Documentation**
Create a folder called `{enhancement['folder']}` and populate it with relevant documentation:
{get_materials_list(scenario_id)}

**Pro tip**: Look for PDF documents, technical guides, and industry best practices.

### **Step 3: Build Your Intelligent Knowledge Base**
```bash
# Navigate to your research folder
cd {enhancement['folder']}

# Initialize FSS-Mini-RAG index  
rag-mini init

# Check the index was created successfully
rag-mini stats

# Get system info to verify everything is working
rag-mini info
```

### **Step 4: Test Your Intelligence System**
Now for the cool part - your documentation is now searchable with natural language! Test these queries:

```bash"""

    # Add search commands
    for cmd in enhancement['commands']:
        instructions += f"\n# {get_command_description(cmd)}\n{cmd}\n"

    instructions += f"""```

### **Step 5: Advanced Searches**
Try these more sophisticated queries:

```bash"""

    # Add advanced commands
    for cmd in enhancement['advanced_commands']:
        instructions += f"\n# {get_advanced_description(cmd)}\n{cmd}\n"

    instructions += f"""
# Update your knowledge base (when you add new documents)
rag-mini update

# Get detailed statistics about your knowledge base
rag-mini stats
```

### **Step 6: Document Your Intelligence System**
Write your findings in `RESULTS.md` including:

#### **Knowledge Base Performance**
- How many documents were indexed?
- How fast were the search responses?
- Which types of questions worked best?

#### **Professional Value** 
{get_professional_questions(enhancement['professional_impact'])}

#### **Professional Impact**
{get_impact_questions(enhancement['professional_impact'])}

{get_completion_workflow(scenario_id, enhancement)}

## 📁 **Final Deliverables**
- `{enhancement['folder']}/` folder with indexed documentation
- `RESULTS.md` with comprehensive evaluation and evidence
- Git branch with proper commit history
- Pull request with detailed description
- Professional assessment of FSS-Mini-RAG effectiveness

## ⏱️ **Expected Duration**: 3-4 hours (including documentation and PR submission)

## 🎉 **Success Outcome**
You'll have created an **intelligent {enhancement['system_name'].lower()}** AND provided valuable feedback to improve FSS-Mini-RAG for industry professionals!

## 🎓 **Learning Objectives**
- Experience semantic search with industry-specific content
- Evaluate AI-powered documentation assistance for professional workflows  
- Test real-world applicability of RAG systems in your industry
- Practice professional software evaluation and contribution workflows"""

    return instructions

def get_role_from_title(title):
    """Extract role from title."""
    roles = {
        "Childcare": "Childcare Center Director",
        "Plant": "Logistics Coordinator", 
        "Financial": "Compliance Officer",
        "Medical": "Clinical Research Coordinator",
    }
    
    for key, role in roles.items():
        if key in title:
            return role
    return "Professional"

def get_materials_list(scenario_id):
    """Get materials list based on scenario.""" 
    # This would be customized per scenario
    return "- Relevant industry documentation\n- Standards and guidelines\n- Best practices documents\n- Regulatory requirements\n- Technical specifications"

def get_command_description(cmd):
    """Get description for search command."""
    return f"Search for specific information"

def get_advanced_description(cmd):
    """Get description for advanced command."""
    return f"Advanced search functionality"

def get_professional_questions(impact_list):
    """Format professional impact questions."""
    return "\n".join([f"- {q}" for q in impact_list])

def get_impact_questions(impact_list):
    """Get impact assessment questions."""
    return "\n".join([f"- {q}" for q in impact_list])

def get_completion_workflow(scenario_id, enhancement):
    """Get the completion workflow with repository details."""
    
    scenario_name = scenario_id.replace('-', '_')
    
    return f"""
### **Step 7: Complete Professional Evaluation**
Rate FSS-Mini-RAG's effectiveness for:
- **Finding specific industry information** (1-10)
- **Answering domain-specific questions** (1-10)  
- **Helping with workflow optimization** (1-10)
- **Overall usefulness for your industry** (1-10)

### **Step 8: Document Your Experience**
Create a comprehensive `RESULTS.md` including:

#### **Executive Summary**
- What you built ({enhancement['system_name']})
- Key findings and success metrics
- Professional impact assessment

#### **Technical Details**
- Number of documents indexed and file sizes
- Search response times and accuracy ratings
- Most effective query types and examples
- Command usage statistics (init, search, stats, info, find-function, find-class, update)

#### **Professional Value Assessment**
- Time saved compared to manual document searching
- Potential impact on industry-specific processes
- Training value for new professionals
- Industry-specific compliance/workflow improvements

#### **User Experience Report**
- Installation process evaluation
- Command usability ratings
- Documentation quality assessment
- Suggested improvements or missing features

### **Step 9: Repository Contribution Workflow**

#### **Repository Information**
- **Repository URL**: `http://192.168.1.3:3000/foxadmin/fss-mini-rag-github.git`
- **Main Branch**: `main`
- **Testing Branch**: `agent-user-testing` (where scenarios are located)

#### **Branch Management**
```bash
# Clone the repository
git clone http://192.168.1.3:3000/foxadmin/fss-mini-rag-github.git
cd fss-mini-rag-github

# Start from the agent-user-testing branch
git checkout agent-user-testing

# Create your own branch for your results
git checkout -b agent-test-{scenario_name}-$(date +%Y%m%d)

# Navigate to your scenario
cd agent-user-testing/{scenario_id}/
```

#### **Submit Your Results**
```bash
# Add your completed RESULTS.md
git add RESULTS.md

# Commit with descriptive message
git commit -m "Agent Test Results: {enhancement['system_name']}

- Tested FSS-Mini-RAG with industry-specific documentation
- Created intelligent knowledge base for domain queries
- Evaluated semantic search effectiveness for professional workflows
- Documented professional impact and time-saving potential
- Rating: [X]/10 overall effectiveness"

# Push your branch
git push origin agent-test-{scenario_name}-$(date +%Y%m%d)
```

#### **Create Pull Request**
```bash
# Use gitea CLI to create PR
gitea prs create "Agent Test: {enhancement['system_name']} Results" agent-test-{scenario_name}-$(date +%Y%m%d) agent-user-testing --body "Completed comprehensive testing of FSS-Mini-RAG for industry workflows.

## Test Summary
- Built {enhancement['system_name']}
- Indexed [X] industry documents
- Tested [X] search queries with [X]% accuracy
- Overall effectiveness rating: [X]/10

## Key Findings
[Brief summary of major discoveries]

## Professional Impact
[Assessment of real-world value for professionals]

## Recommendations
[Suggestions for improvements or additional features]"
```

### **Step 10: Validation Requirements**

Your submission must include:

#### **Required Evidence**
- ✅ **Screenshots** of successful `rag-mini init` and `rag-mini stats` output
- ✅ **Search examples** with actual query results (at least 5 different searches)
- ✅ **Performance metrics** (response times, index size, document count)
- ✅ **Professional assessment** with specific use cases and value propositions

#### **Quality Standards**
- ✅ **Functional completeness**: All major commands tested (init, search, stats, info)
- ✅ **Real-world relevance**: Actual industry documents and realistic queries
- ✅ **Professional writing**: Clear, actionable insights for industry teams
- ✅ **Quantitative data**: Specific metrics and measurable outcomes

#### **Submission Checklist**
- [ ] Created intelligent knowledge base successfully
- [ ] Tested minimum 5 different search queries
- [ ] Documented all command usage and results
- [ ] Provided professional impact assessment
- [ ] Created proper git branch with descriptive name
- [ ] Submitted PR with comprehensive description
- [ ] Included evidence screenshots/outputs
- [ ] Met all validation requirements"""

def main():
    """Generate enhanced instructions for key scenarios."""
    
    print("Enhancing agent testing scenarios with functional demonstrations...")
    
    for scenario_id, enhancement in scenario_enhancements.items():
        scenario_dir = Path(f"agent-user-testing/{scenario_id}")
        if scenario_dir.exists():
            print(f"Enhancing scenario: {scenario_id}")
            
            instructions_file = scenario_dir / "INSTRUCTIONS.md"
            instructions_content = create_functional_instructions(scenario_id, enhancement)
            
            with open(instructions_file, 'w') as f:
                f.write(instructions_content)
            
            print(f"  ✅ Updated {instructions_file}")
        else:
            print(f"  ⚠️  Scenario directory not found: {scenario_dir}")
    
    print(f"\\nEnhanced {len(scenario_enhancements)} scenarios with functional demonstrations!")

if __name__ == "__main__":
    main()