app.py

import gradio as gr
import json
import time
import random
from datetime import datetime, timedelta
from functools import lru_cache

# Optimized demo controller
class OptimizedEnterpriseDemo:
    def __init__(self):
        self.request_count = 0
        self.total_time_saved = 0
        
    def calculate_business_impact(self, story_complexity="medium"):
        """Calculate concise business impact metrics"""
        traditional_times = {"simple": 4, "medium": 8, "complex": 16}
        traditional_hours = traditional_times.get(story_complexity, 8)
        genai_time_minutes = 3
        
        time_saved_hours = traditional_hours - (genai_time_minutes / 60)
        efficiency_gain = (time_saved_hours / traditional_hours) * 100
        cost_saved = time_saved_hours * 75  # $75/hour QA rate
        
        self.total_time_saved += time_saved_hours
        self.request_count += 1
        
        return {
            "traditional_hours": traditional_hours,
            "time_saved_hours": round(time_saved_hours, 1),
            "efficiency_gain": round(efficiency_gain, 1),
            "cost_saved": round(cost_saved, 2)
        }

demo_controller = OptimizedEnterpriseDemo()

# Simplified user stories
ENTERPRISE_STORIES = [
    {
        "id": 1,
        "title": "Premium Payment Processing",
        "description": "As a policyholder, I want to pay my premium using multiple payment methods with real-time validation and fraud detection so my payment is secure and processed immediately.",
        "complexity": "complex",
        "priority": "Critical"
    },
    {
        "id": 2,
        "title": "Claims Processing Automation", 
        "description": "As a claims adjuster, I want automated claims processing that validates documents, checks coverage, and detects fraud so I can process claims efficiently.",
        "complexity": "complex",
        "priority": "High"
    },
    {
        "id": 3,
        "title": "Invoice Generation & Compliance",
        "description": "As a billing admin, I want automated invoice generation with regulatory compliance and tax calculations so invoices meet legal standards.",
        "complexity": "medium",
        "priority": "High"
    },
    {
        "id": 4,
        "title": "Customer Onboarding",
        "description": "As a new customer, I want streamlined onboarding with risk assessment and quote generation so I can get coverage quickly.",
        "complexity": "medium", 
        "priority": "Medium"
    },
    {
        "id": 5,
        "title": "Policy Renewal & Dynamic Pricing",
        "description": "As a policyholder, I want automatic renewal with updated premiums based on current risk factors and claims history.",
        "complexity": "complex",
        "priority": "Medium"
    }
]

def analyze_requirements_concise(user_story):
    """Concise requirement analysis"""
    if "payment" in user_story.lower():
        return {
            "gaps": ["Payment retry logic", "Currency handling", "Timeout values"],
            "rules": ["PCI compliance required", "Fraud detection mandatory", "Audit trail needed"],
            "coverage": ["Security", "Integration", "Compliance"]
        }
    elif "claims" in user_story.lower():
        return {
            "gaps": ["Document formats", "Approval thresholds", "Appeal process"],
            "rules": ["Policy validation required", "High-value manual review", "Fraud alerts immediate"],
            "coverage": ["Document Processing", "Business Rules", "Fraud Detection"]
        }
    else:
        return {
            "gaps": ["Success criteria", "Error handling", "Performance SLAs"],
            "rules": ["Data validation required", "Audit trail mandatory", "User feedback needed"],
            "coverage": ["Functional", "Security", "Performance"]
        }

def generate_concise_bdd(user_story, analysis):
    """Generate focused BDD scenario"""
    if "payment" in user_story.lower():
        return """Feature: Premium Payment Processing
  Secure payment processing with fraud detection

Scenario: Successful credit card payment
  Given I have a valid policy and credit card
  When I process payment of $1,200
  Then payment is validated and processed
  And fraud detection approves transaction
  And confirmation is sent

Scenario: Payment failure handling
  Given insufficient funds on my card
  When I attempt payment
  Then I receive clear error message
  And alternative payment options offered
  And attempt is logged for audit"""
    
    elif "claims" in user_story.lower():
        return """Feature: Automated Claims Processing
  Efficient claim validation and processing

Scenario: Successful claim processing
  Given valid claim with documentation
  When automated processing runs
  Then documents are validated
  And policy coverage is verified
  And settlement is calculated
  And approval is generated

Scenario: High-value claim review
  Given claim exceeds $10,000 threshold
  When processing begins
  Then claim is flagged for manual review
  And adjuster is notified
  And summary is provided"""
    
    else:
        return """Feature: Core System Functionality
  Reliable business operations

Scenario: Successful operation
  Given authorized user access
  When performing business operation
  Then system validates inputs
  And processes according to rules
  And provides appropriate feedback
  And maintains audit trail"""

def generate_focused_test_script():
    """Generate concise, focused test script"""
    return '''import pytest
from unittest.mock import Mock, patch
from datetime import datetime

class TestInsuranceSystem:
    """Enterprise insurance system tests"""
    
    def setup_method(self):
        self.policy = {"id": "POL-12345", "premium": 1200.00}
        self.payment_service = Mock()
        self.fraud_detector = Mock()
        
    @patch('payment.PaymentGateway')
    def test_successful_payment_processing(self, mock_gateway):
        """Test end-to-end payment processing"""
        # Given
        mock_gateway.return_value.process.return_value = {
            "status": "SUCCESS", "txn_id": "TXN-001"
        }
        
        # When
        result = self.payment_service.process_payment(
            self.policy["id"], 1200.00
        )
        
        # Then
        assert result["status"] == "SUCCESS"
        assert result["txn_id"] is not None
        mock_gateway.return_value.process.assert_called_once()
        
    def test_fraud_detection_integration(self):
        """Test fraud detection workflow"""
        # Given
        self.fraud_detector.analyze.return_value = {
            "risk_score": 8.5, "approved": False
        }
        
        # When
        result = self.payment_service.validate_transaction(
            self.policy["id"], 1200.00
        )
        
        # Then
        assert result["blocked"] is True
        assert result["reason"] == "HIGH_RISK"
        
    def test_audit_trail_creation(self):
        """Test comprehensive audit logging"""
        # When
        self.payment_service.process_payment(
            self.policy["id"], 1200.00
        )
        
        # Then
        self.payment_service.audit_log.assert_called()'''

def simulate_concise_execution(complexity, coverage_areas):
    """Generate concise execution results"""
    test_counts = {"simple": 8, "medium": 12, "complex": 18}
    total = test_counts.get(complexity, 12)
    
    # Simulate realistic pass/fail rates
    if complexity == "complex":
        passed = random.randint(14, 16)
    else:
        passed = random.randint(total-2, total)
    
    failed = total - passed
    execution_time = round(random.uniform(1.8, 3.2), 1)
    
    return {
        "status": "PASS" if failed == 0 else "FAIL",
        "total": total,
        "passed": passed,
        "failed": failed,
        "time": execution_time,
        "coverage_areas": coverage_areas,
        "performance": {
            "response_time": random.randint(120, 450),
            "memory_mb": random.randint(45, 95),
            "cpu_percent": random.randint(15, 55)
        }
    }

def generate_qa_ai_feedback(execution_result, story_complexity, business_impact):
    """Generate QA-AI tester feedback and recommendations"""
    
    if execution_result["status"] == "PASS":
        feedback = f"""🤖 **QA-AI Tester Review: ✅ APPROVED**

**Quality Assessment:** All {execution_result['total']} tests passed
**Performance Grade:** A+ (Response: {execution_result['performance']['response_time']}ms)
**Coverage Score:** 98% - Comprehensive validation achieved

**🎯 AI Recommendations:**
• Ready for production deployment
• Consider adding performance monitoring
• Implement automated regression suite

**⚡ Efficiency Gains:**
• **Time Saved:** {business_impact['time_saved_hours']} hours
• **Cost Reduced:** ${business_impact['cost_saved']}
• **Quality Improved:** {len(execution_result['coverage_areas'])} areas validated"""
    
    else:
        feedback = f"""🤖 **QA-AI Tester Review: ⚠️ NEEDS ATTENTION**

**Quality Assessment:** {execution_result['failed']} of {execution_result['total']} tests failed
**Risk Level:** {'High' if execution_result['failed'] > 3 else 'Medium'}
**Performance Impact:** {execution_result['performance']['response_time']}ms response time

**🔧 AI-Powered Fix Suggestions:**
• Priority 1: Address {execution_result['coverage_areas'][0]} failures
• Priority 2: Optimize performance (target <300ms)
• Priority 3: Enhanced error handling needed

**📊 Business Impact:**
• **Deployment Risk:** Production issues likely
• **Customer Impact:** {random.randint(200, 800)} users affected
• **Revenue Risk:** ${random.randint(10000, 50000)} potential loss

**🚀 Next Steps:**
1. Fix critical failures (Est: 2-4 hours)
2. Re-run validation suite
3. Performance optimization review"""
    
    return feedback

def process_optimized_lifecycle(selected_story_id, custom_story=""):
    """Streamlined test lifecycle process"""
    
    try:
        # Get story details
        if custom_story.strip():
            user_story = custom_story.strip()
            story_title = "Custom Story"
            complexity = "medium"
        else:
            story = next((s for s in ENTERPRISE_STORIES if s["id"] == int(selected_story_id)), None)
            if not story:
                return "❌ Story not found", "", "", "", "", "", ""
            user_story = story["description"]
            story_title = story["title"]
            complexity = story["complexity"]
        
        business_impact = demo_controller.calculate_business_impact(complexity)
        
        # Step 1: Requirements Analysis
        yield (
            f"🔍 Analyzing: {story_title}",
            f"**User Story:** {user_story}\n\n**Complexity:** {complexity.title()} | **Traditional Time:** {business_impact['traditional_hours']} hours",
            "⏳ AI analyzing requirements...",
            "", "", "", ""
        )
        
        time.sleep(1)
        analysis = analyze_requirements_concise(user_story)
        
        requirements_output = f"""**🧠 AI Requirements Analysis:**

**Missing Requirements:** {', '.join(analysis['gaps'][:2])}
**Business Rules:** {len(analysis['rules'])} rules identified
**Test Coverage:** {', '.join(analysis['coverage'])} areas"""
        
        # Step 2: BDD Generation
        yield (
            f"✅ Requirements Complete: {story_title}",
            f"**User Story:** {user_story}\n\n**Time Saved:** {business_impact['time_saved_hours']} hours | **Cost Saved:** ${business_impact['cost_saved']}",
            requirements_output,
            "⏳ Generating BDD scenarios...",
            "", "", ""
        )
        
        time.sleep(1.5)
        bdd_scenario = generate_concise_bdd(user_story, analysis)
        
        # Step 3: Test Script Generation
        yield (
            f"✅ BDD Generated: {story_title}",
            f"**User Story:** {user_story}\n\n**Efficiency Gain:** {business_impact['efficiency_gain']}%",
            requirements_output,
            f"**🎯 BDD Scenarios:**\n```gherkin\n{bdd_scenario}\n```",
            "⏳ Creating test scripts...",
            "", ""
        )
        
        time.sleep(1.5)
        test_script = generate_focused_test_script()
        
        # Step 4: Test Execution
        yield (
            f"✅ Scripts Ready: {story_title}",
            f"**User Story:** {user_story}\n\n**ROI:** {business_impact['efficiency_gain']}% improvement",
            requirements_output,
            f"**🎯 BDD Scenarios:**\n```gherkin\n{bdd_scenario}\n```",
            f"**🧪 Test Scripts:**\n```python\n{test_script}\n```",
            "⚡ Executing tests...",
            ""
        )
        
        time.sleep(2)
        execution_result = simulate_concise_execution(complexity, analysis['coverage'])
        
        status_icon = "✅" if execution_result["status"] == "PASS" else "❌"
        
        execution_output = f"""**{status_icon} Test Results:** {execution_result['status']}

**Tests:** {execution_result['passed']}/{execution_result['total']} passed | **Time:** {execution_result['time']}s
**Performance:** {execution_result['performance']['response_time']}ms avg response
**Coverage:** {', '.join(execution_result['coverage_areas'])}"""
        
        # Step 5: QA-AI Feedback
        yield (
            f"✅ Testing Complete: {story_title}",
            f"**User Story:** {user_story}\n\n**Business Value:** ${business_impact['cost_saved']} saved",
            requirements_output,
            f"**🎯 BDD Scenarios:**\n```gherkin\n{bdd_scenario}\n```",
            f"**🧪 Test Scripts:**\n```python\n{test_script}\n```",
            execution_output,
            "🤖 Generating AI tester feedback..."
        )
        
        time.sleep(1)
        qa_feedback = generate_qa_ai_feedback(execution_result, complexity, business_impact)
        
        # Final Result
        yield (
            f"🎉 Complete: {story_title}",
            f"**User Story:** {user_story}\n\n**Value Delivered:** {business_impact['time_saved_hours']} hours saved, ${business_impact['cost_saved']} cost reduction",
            requirements_output,
            f"**🎯 BDD Scenarios:**\n```gherkin\n{bdd_scenario}\n```",
            f"**🧪 Test Scripts:**\n```python\n{test_script}\n```",
            execution_output,
            qa_feedback
        )
        
    except Exception as e:
        yield (
            "❌ Error occurred",
            f"Error: {str(e)}",
            "", "", "", "", ""
        )

# Clean, focused Gradio interface
with gr.Blocks(
    theme=gr.themes.Soft(),
    title="Enterprise STLC-AI",
    css="""
    .gradio-container {
        max-width: 1200px !important; 
        margin: 0 auto;
        padding-bottom: 0 !important;
    }
    .header-banner {
        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); 
        color: white; 
        padding: 20px; 
        border-radius: 15px; 
        text-align: center; 
        margin-bottom: 20px;
    }
    .metrics-box {
        background: #f8f9fa; 
        padding: 15px; 
        border-radius: 10px; 
        border-left: 4px solid #007bff;
    }
    .compact-accordion .accordion {
        margin: 5px 0;
    }
    /* Remove extra spacing */
    .footer {
        margin-bottom: 0 !important;
        padding-bottom: 0 !important;
    }
    .block {
        margin-bottom: 0 !important;
    }
    /* Remove yellow highlighting/selection */
    ::selection {
        background-color: transparent;
    }
    ::-moz-selection {
        background-color: transparent;
    }
    /* Ensure no extra space at bottom */
    body {
        margin-bottom: 0 !important;
        padding-bottom: 0 !important;
    }
    .gradio-app {
        margin-bottom: 0 !important;
        padding-bottom: 0 !important;
    }
    """
) as demo:
    
    # Header
    gr.HTML("""
    <div class="header-banner">
        <h1>🏢 Enterprise STLC-AI: GenAI QA Automation</h1>
        <p><strong>Transform 16-hour QA cycles into 3-minute automated workflows</strong></p>
    </div>
    """)
    
    with gr.Row():
        # Left Panel - Controls
        with gr.Column(scale=1):
            gr.Markdown("### 🎯 Select Enterprise Scenario")
            
            story_dropdown = gr.Dropdown(
                choices=[(f"{s['title']} ({s['complexity'].title()})", str(s['id'])) for s in ENTERPRISE_STORIES],
                label="Pre-built Scenarios",
                value="1"
            )
            
            custom_story_input = gr.Textbox(
                label="Custom Story",
                placeholder="As a [role], I want [goal] so that [benefit]...",
                lines=2
            )
            
            process_btn = gr.Button("🚀 Start QA Automation", variant="primary", size="lg")
            
            # Compact metrics
            gr.HTML(f"""
            <div class="metrics-box">
                <h4>📊 Live Demo Stats</h4>
                <p><strong>Scenarios:</strong> {len(ENTERPRISE_STORIES)} enterprise cases<br>
                <strong>Avg Savings:</strong> 12+ hours per story<br>
                <strong>Processed:</strong> {demo_controller.request_count} stories<br>
                <strong>Total Saved:</strong> {demo_controller.total_time_saved:.1f} hours</p>
            </div>
            """)
        
        # Right Panel - Results
        with gr.Column(scale=2):
            status_display = gr.Textbox(label="🔄 Status", interactive=False)
            
            with gr.Accordion("📋 Business Context", open=True):
                story_output = gr.Markdown()
            
            with gr.Accordion("🧠 AI Analysis", open=True):
                requirements_output = gr.Markdown()
            
            with gr.Accordion("🎯 BDD Scenarios", open=False):
                bdd_output = gr.Markdown()
            
            with gr.Accordion("🧪 Test Scripts", open=False):
                script_output = gr.Markdown()
            
            with gr.Accordion("⚡ Test Results", open=False):
                execution_output = gr.Markdown()
            
            with gr.Accordion("🤖 QA-AI Review", open=True):
                feedback_output = gr.Markdown()
    
    # Event binding
    process_btn.click(
        fn=process_optimized_lifecycle,
        inputs=[story_dropdown, custom_story_input],
        outputs=[status_display, story_output, requirements_output, bdd_output, script_output, execution_output, feedback_output]
    )
    
    # Footer with key benefits (compact, no extra spacing)
    gr.HTML("""
    <div style="margin: 20px 0 0 0; padding: 15px; background: #f8f9fa; border-radius: 10px;">
        <h3 style="margin: 0 0 10px 0;">🎯 Enterprise Benefits Demonstrated</h3>
        <p style="margin: 0;"><strong>⚡ Speed:</strong> 95% faster test creation | <strong>💰 Cost:</strong> 75% reduction in QA effort | <strong>🎯 Quality:</strong> 100% coverage assurance | <strong>🤖 Intelligence:</strong> AI-powered analysis & feedback</p>
        <p style="margin: 5px 0 0 0; font-style: italic;">This demo shows how GenAI transforms traditional 16-hour QA cycles into 3-minute automated workflows with superior quality and coverage.</p>
    </div>
    """)

if __name__ == "__main__":
    demo.launch(
        share=False,
        server_name="0.0.0.0",
        server_port=7860,
        show_error=True
    )