Restore scenario analysis feature - core project functionality

✅ Restored Files:
- scenario_analysis_service.py - Main scenario analysis engine
- policy_chart_generator.py - Policy visualization charts
- policy_impact_simulator.py - Policy impact simulation
- policy_simulator_api.py - API endpoints for policy simulation
- policy_chat_interface.py - Interactive policy chat

🔧 Fixed Imports:
- Restored scenario_service import in rag_service.py
- Added ScenarioAnalysisService to app.py
- Fixed module not found errors

🎯 Features Available:
- Government scenario analysis
- Policy impact visualization
- Interactive policy simulations
- Chart generation for policy data

app.py

@@ -11,6 +11,7 @@ from hybrid_llm_service import HybridLLMService
 from voice_service import VoiceService
 from rag_service import search_documents
 from lancedb_service import LanceDBService
+from scenario_analysis_service import ScenarioAnalysisService
 import config
 from dotenv import load_dotenv
 
@@ -68,6 +69,7 @@ app.add_middleware(
 llm_service = None
 voice_service = None
 lancedb_service = None
+scenario_service = None
 
 def get_llm_service():
     global llm_service
@@ -87,6 +89,12 @@ def get_lancedb_service():
         lancedb_service = LanceDBService()
     return lancedb_service
 
+def get_scenario_service():
+    global scenario_service
+    if scenario_service is None:
+        scenario_service = ScenarioAnalysisService()
+    return scenario_service
+
 # Health check endpoint
 @app.get("/health")
 async def health_check():

policy_chart_generator.py

@@ -0,0 +1,231 @@
+"""
+Chart Generation for Policy Impact Simulator
+Creates visual charts and graphs for policy analysis results
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+from typing import Dict, Any, List
+import os
+import base64
+import io
+from datetime import datetime
+
+class PolicyChartGenerator:
+    """Generates charts and graphs for policy impact analysis"""
+    
+    def __init__(self):
+        # Set matplotlib to use non-interactive backend
+        plt.switch_backend('Agg')
+        
+    def generate_scenario_comparison_chart(self, variants: Dict[str, Any], title: str = "Policy Scenario Analysis") -> str:
+        """Generate a bar chart comparing scenario variants"""
+        
+        # Extract scenario data
+        scenario_names = []
+        costs = []
+        colors = []
+        
+        color_map = {
+            'best_case': '#28a745',  # Green
+            'base_case': '#007bff',  # Blue  
+            'worst_case': '#dc3545'  # Red
+        }
+        
+        for scenario_type, data in variants.items():
+            if isinstance(data, dict) and 'total_cost' in data:
+                scenario_names.append(scenario_type.replace('_', ' ').title())
+                costs.append(data['total_cost'])
+                colors.append(color_map.get(scenario_type, '#6c757d'))
+        
+        # Create chart
+        fig, ax = plt.subplots(figsize=(10, 6))
+        bars = ax.bar(scenario_names, costs, color=colors, alpha=0.8)
+        
+        # Customize chart
+        ax.set_title(title, fontsize=16, fontweight='bold', pad=20)
+        ax.set_ylabel('Total Cost (₹ Crores)', fontsize=12)
+        ax.set_xlabel('Scenario', fontsize=12)
+        
+        # Add value labels on bars
+        for bar, cost in zip(bars, costs):
+            height = bar.get_height()
+            ax.text(bar.get_x() + bar.get_width()/2., height + max(costs) * 0.01,
+                   f'₹{cost:,.0f}', ha='center', va='bottom', fontweight='bold')
+        
+        # Format y-axis
+        ax.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'₹{x:,.0f}'))
+        
+        # Add grid
+        ax.grid(True, alpha=0.3, axis='y')
+        ax.set_axisbelow(True)
+        
+        # Tight layout
+        plt.tight_layout()
+        
+        # Convert to base64 string
+        return self._fig_to_base64(fig)
+    
+    def generate_yearly_breakdown_chart(self, yearly_data: List[Dict], title: str = "Yearly Impact Breakdown") -> str:
+        """Generate a line chart showing yearly breakdown"""
+        
+        years = []
+        impacts = []
+        beneficiaries = []
+        
+        for year_data in yearly_data:
+            years.append(f"Year {year_data.get('year', 0)}")
+            impacts.append(year_data.get('impact', 0))
+            beneficiaries.append(year_data.get('affected_beneficiaries', 0))
+        
+        # Create dual-axis chart
+        fig, ax1 = plt.subplots(figsize=(12, 6))
+        
+        # Plot impact on primary axis
+        color1 = '#007bff'
+        ax1.set_xlabel('Years', fontsize=12)
+        ax1.set_ylabel('Impact (₹ Crores)', fontsize=12, color=color1)
+        line1 = ax1.plot(years, impacts, color=color1, marker='o', linewidth=3, markersize=8, label='Financial Impact')
+        ax1.tick_params(axis='y', labelcolor=color1)
+        ax1.grid(True, alpha=0.3)
+        
+        # Create secondary axis for beneficiaries
+        ax2 = ax1.twinx()
+        color2 = '#28a745'
+        ax2.set_ylabel('Beneficiaries', fontsize=12, color=color2)
+        line2 = ax2.plot(years, beneficiaries, color=color2, marker='s', linewidth=3, markersize=8, linestyle='--', label='Affected Population')
+        ax2.tick_params(axis='y', labelcolor=color2)
+        
+        # Add title
+        ax1.set_title(title, fontsize=16, fontweight='bold', pad=20)
+        
+        # Add value labels
+        for i, (year, impact, beneficiary) in enumerate(zip(years, impacts, beneficiaries)):
+            ax1.annotate(f'₹{impact:.1f}', (i, impact), textcoords="offset points", xytext=(0,10), ha='center', fontweight='bold')
+            ax2.annotate(f'{beneficiary:,}', (i, beneficiary), textcoords="offset points", xytext=(0,-15), ha='center', fontweight='bold', color=color2)
+        
+        # Add legend
+        lines1, labels1 = ax1.get_legend_handles_labels()
+        lines2, labels2 = ax2.get_legend_handles_labels()
+        ax1.legend(lines1 + lines2, labels1 + labels2, loc='upper left')
+        
+        plt.tight_layout()
+        return self._fig_to_base64(fig)
+    
+    def generate_ascii_chart(self, variants: Dict[str, Any], width: int = 50) -> str:
+        """Generate ASCII chart for text-based display"""
+        
+        if not variants:
+            return "No data available for chart generation"
+        
+        # Extract costs
+        costs = []
+        names = []
+        for scenario_type, data in variants.items():
+            if isinstance(data, dict) and 'total_cost' in data:
+                costs.append(data['total_cost'])
+                names.append(scenario_type.replace('_', ' ').title())
+        
+        if not costs:
+            return "No cost data available"
+        
+        max_cost = max(costs) if costs else 1
+        
+        chart = "📊 Policy Scenario Comparison (₹ Crores)\n"
+        chart += "=" * (width + 20) + "\n"
+        
+        for name, cost in zip(names, costs):
+            # Calculate bar length
+            bar_length = int((cost / max_cost) * width) if max_cost > 0 else 0
+            bar = "█" * bar_length
+            
+            # Add emoji based on scenario type
+            emoji = "🟢" if "Best" in name else "🔴" if "Worst" in name else "🔵"
+            
+            chart += f"{emoji} {name:12} │{bar:<{width}} ₹{cost:,.0f}\n"
+        
+        chart += "=" * (width + 20) + "\n"
+        return chart
+    
+    def generate_implementation_timeline_chart(self, timeline_data: Dict[str, Any]) -> str:
+        """Generate ASCII timeline chart for implementation phases"""
+        
+        phases = [
+            "📋 Planning Phase (Months 1-3)",
+            "⚖️ Legal Review (Months 2-4)", 
+            "💰 Budget Approval (Months 4-6)",
+            "🔄 System Updates (Months 6-8)",
+            "📢 Communication (Months 8-10)",
+            "🚀 Implementation (Months 10-12)"
+        ]
+        
+        timeline = "🗓️ Implementation Timeline\n"
+        timeline += "=" * 60 + "\n"
+        
+        for i, phase in enumerate(phases, 1):
+            progress_bar = "▓" * (i * 2) + "░" * ((6 - i) * 2)
+            timeline += f"  {phase}\n"
+            timeline += f"  [{progress_bar}] {i}/6 phases\n\n"
+        
+        complexity = timeline_data.get('complexity', 'Medium')
+        timeline += f"🔧 Implementation Complexity: {complexity}\n"
+        timeline += f"⏱️ Estimated Duration: 12 months\n"
+        timeline += f"💡 Key Success Factors: Budget approval, stakeholder buy-in, system readiness\n"
+        
+        return timeline
+    
+    def _fig_to_base64(self, fig) -> str:
+        """Convert matplotlib figure to base64 string"""
+        
+        buffer = io.BytesIO()
+        fig.savefig(buffer, format='png', dpi=300, bbox_inches='tight')
+        buffer.seek(0)
+        
+        # Convert to base64
+        img_base64 = base64.b64encode(buffer.read()).decode('utf-8')
+        
+        # Close figure to free memory
+        plt.close(fig)
+        
+        return f"data:image/png;base64,{img_base64}"
+    
+    def generate_comprehensive_report_charts(self, analysis_data: Dict[str, Any]) -> Dict[str, str]:
+        """Generate all charts for a comprehensive policy analysis report"""
+        
+        charts = {}
+        
+        # Scenario comparison chart
+        if 'variants' in analysis_data:
+            charts['scenario_comparison'] = self.generate_scenario_comparison_chart(
+                analysis_data['variants'],
+                f"Policy Impact: {analysis_data.get('parameter_name', 'Analysis')}"
+            )
+            
+            # ASCII version for text display
+            charts['scenario_ascii'] = self.generate_ascii_chart(analysis_data['variants'])
+        
+        # Yearly breakdown chart
+        if 'scenario_projections' in analysis_data:
+            charts['yearly_breakdown'] = self.generate_yearly_breakdown_chart(
+                analysis_data['scenario_projections'],
+                "Financial Impact Over Time"
+            )
+        
+        # Implementation timeline
+        if 'implementation' in analysis_data:
+            charts['implementation_timeline'] = self.generate_implementation_timeline_chart(
+                analysis_data['implementation']
+            )
+        
+        return charts
+
+# Standalone functions for easy integration
+def generate_policy_charts(analysis_data: Dict[str, Any]) -> Dict[str, str]:
+    """Generate charts for policy analysis data"""
+    generator = PolicyChartGenerator()
+    return generator.generate_comprehensive_report_charts(analysis_data)
+
+def generate_ascii_scenario_chart(variants: Dict[str, Any]) -> str:
+    """Generate ASCII chart for immediate text display"""
+    generator = PolicyChartGenerator()
+    return generator.generate_ascii_chart(variants)

policy_chat_interface.py

@@ -0,0 +1,668 @@
+"""
+Policy Impact Simulator Chat Integration
+Provides natural language interface for policy impact simulation
+"""
+
+import re
+import json
+import logging
+from typing import Dict, Any, Optional, List
+from datetime import datetime, timedelta
+from dataclasses import dataclass
+
+from policy_impact_simulator import (
+    PolicyImpactSimulator, 
+    PolicyScenario, 
+    PolicyParameter
+)
+from policy_chart_generator import PolicyChartGenerator
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class PolicyQuery:
+    """Parsed policy query from natural language"""
+    intent: str
+    parameter: Optional[PolicyParameter]
+    current_value: Optional[float]
+    proposed_value: Optional[float]
+    years: int = 5
+    raw_query: str = ""
+
+class PolicySimulatorChatInterface:
+    """Chat interface for policy impact simulation"""
+    
+    def __init__(self):
+        self.simulator = PolicyImpactSimulator()
+        self.chart_generator = PolicyChartGenerator()
+        self.conversation_context = {}
+        
+        # Enhanced pattern matching for natural language queries
+        self.patterns = {
+            "simulate_dr": [
+                r"simulate.*dearness.*relief.*(\d+).*to.*(\d+)",
+                r"dr.*increase.*from.*(\d+).*to.*(\d+)",
+                r"what.*if.*dr.*changes.*(\d+).*(\d+)",
+                r"impact.*dearness.*(\d+).*percent.*(\d+).*percent",
+                r"dr.*analysis.*(\d+).*(\d+)",
+                r"dearness.*relief.*(\d+).*(\d+)",
+                r"impact.*increasing.*dr.*by.*(\d+)",
+                r"show.*impact.*dr.*by.*(\d+)",
+                r"dr.*increase.*by.*(\d+).*percent",
+                r"increase.*dr.*by.*(\d+)"
+            ],
+            "simulate_pension": [
+                r"simulate.*basic.*pension.*(\d+).*to.*(\d+)",
+                r"pension.*increase.*from.*(\d+).*to.*(\d+)",
+                r"what.*if.*pension.*changes.*(\d+).*(\d+)",
+                r"impact.*basic.*pension.*(\d+).*(\d+)",
+                r"pension.*boost.*(\d+).*(\d+)",
+                r"basic.*pension.*(\d+).*(\d+)",
+                r"analyze.*minimum.*pension.*changes",
+                r"analyze.*basic.*pension",
+                r"minimum.*pension.*analysis",
+                r"basic.*pension.*impact"
+            ],
+            "simulate_medical": [
+                r"simulate.*medical.*allowance.*(\d+).*to.*(\d+)",
+                r"medical.*increase.*from.*(\d+).*to.*(\d+)",
+                r"what.*if.*medical.*changes.*(\d+).*(\d+)",
+                r"medical.*allowance.*(\d+).*(\d+)"
+            ],
+            "scenario_analysis": [
+                r"scenario.*analysis.*pension",
+                r"do.*scenario.*analysis",
+                r"pension.*scenario.*analysis",
+                r"analyze.*pension.*scenarios",
+                r"scenario.*analysis.*dr",
+                r"pension.*rules.*scenario",
+                r"government.*policy.*scenario",
+                r"policy.*scenario.*analysis"
+            ],
+            "interactive_form": [
+                r"start.*scenario.*analysis",
+                r"interactive.*scenario",
+                r"step.*by.*step.*analysis",
+                r"guided.*analysis",
+                r"scenario.*form"
+            ],
+            "general_policy": [
+                r"policy.*impact.*simulation",
+                r"simulate.*policy.*change",
+                r"what.*if.*we.*change",
+                r"impact.*analysis.*policy",
+                r"policy.*analysis",
+                r"government.*policy.*impact"
+            ],
+            "compare_scenarios": [
+                r"compare.*scenarios",
+                r"which.*is.*better.*policy",
+                r"cost.*comparison.*policies",
+                r"scenario.*comparison",
+                r"best.*case.*worst.*case"
+            ]
+        }
+    
+    def process_policy_query(self, query: str, user_id: str = "default") -> Dict[str, Any]:
+        """
+        Process natural language policy query and return simulation results
+        """
+        try:
+            # Parse the query
+            parsed_query = self._parse_policy_query(query)
+            
+            if not parsed_query:
+                return self._get_help_response()
+            
+            # Handle different intents
+            if parsed_query.intent == "simulate":
+                return self._handle_simulation_request(parsed_query, user_id)
+            elif parsed_query.intent == "compare":
+                return self._handle_comparison_request(parsed_query, user_id)
+            elif parsed_query.intent == "help":
+                return self._get_help_response()
+            elif parsed_query.intent == "scenario_analysis":
+                return self._handle_scenario_analysis_request(parsed_query, user_id)
+            elif parsed_query.intent == "interactive_form":
+                return self._start_interactive_form(user_id)
+            else:
+                return self._get_clarification_response(query)
+                
+        except Exception as e:
+            logger.error(f"Policy query processing error: {e}")
+            return {
+                "type": "error",
+                "message": f"Sorry, I encountered an error processing your policy query: {str(e)}",
+                "suggestions": ["Try rephrasing your question", "Use specific numbers and policy parameters"]
+            }
+    
+    def _parse_policy_query(self, query: str) -> Optional[PolicyQuery]:
+        """Parse natural language query into structured policy query"""
+        query_lower = query.lower()
+        
+        # Check for explicit help requests (more specific to avoid false positives)
+        help_patterns = [r"^help", r"how.*do.*i", r"what.*can.*you", r"guide.*me", r"need.*help"]
+        if any(re.search(pattern, query_lower) for pattern in help_patterns):
+            return PolicyQuery(intent="help", parameter=None, current_value=None, proposed_value=None, raw_query=query)
+        
+        # Check for comparison requests
+        if any(word in query_lower for word in ["compare", "vs", "versus", "which is better"]):
+            return PolicyQuery(intent="compare", parameter=None, current_value=None, proposed_value=None, raw_query=query)
+        
+        # Try to match simulation patterns
+        for intent, patterns in self.patterns.items():
+            for pattern in patterns:
+                match = re.search(pattern, query_lower)
+                if match:
+                    return self._extract_simulation_params(intent, match, query)
+        
+        # Check for general policy simulation intent
+        if any(word in query_lower for word in ["simulate", "impact", "policy", "change", "effect"]):
+            return PolicyQuery(intent="simulate", parameter=None, current_value=None, proposed_value=None, raw_query=query)
+        
+        return None
+    
+    def _extract_simulation_params(self, intent: str, match, raw_query: str) -> PolicyQuery:
+        """Extract simulation parameters from regex match"""
+        try:
+            # Handle new intent types that don't need parameter extraction
+            if intent in ["scenario_analysis", "interactive_form"]:
+                return PolicyQuery(
+                    intent=intent,
+                    parameter=None,
+                    current_value=None,
+                    proposed_value=None,
+                    raw_query=raw_query
+                )
+            
+            groups = match.groups()
+            
+            # Map intent to parameter for simulation intents
+            parameter_mapping = {
+                "simulate_dr": PolicyParameter.DEARNESS_RELIEF,
+                "simulate_pension": PolicyParameter.BASIC_PENSION,
+                "simulate_medical": PolicyParameter.MEDICAL_ALLOWANCE
+            }
+            
+            parameter = parameter_mapping.get(intent, PolicyParameter.DEARNESS_RELIEF)
+            
+            # Handle different pattern types
+            if len(groups) == 0:
+                # No numbers - provide default analysis scenario
+                if parameter == PolicyParameter.DEARNESS_RELIEF:
+                    current_value = 12.0  # Current DR is 12%
+                    proposed_value = 18.0  # Standard 6% increase
+                elif parameter == PolicyParameter.BASIC_PENSION:
+                    current_value = 6000.0  # Current basic pension is ₹6,000
+                    proposed_value = 8000.0  # Standard ₹2,000 increase
+                elif parameter == PolicyParameter.MEDICAL_ALLOWANCE:
+                    current_value = 1000.0  # Current medical allowance is ₹1,000
+                    proposed_value = 1500.0  # Standard ₹500 increase
+                else:
+                    current_value = 0.0
+                    proposed_value = 1.0
+            elif len(groups) == 1:
+                # Single number - treat as percentage increase
+                increase_amount = float(groups[0])
+                
+                # Set current values based on parameter type
+                if parameter == PolicyParameter.DEARNESS_RELIEF:
+                    current_value = 12.0  # Current DR is 12%
+                    proposed_value = current_value + increase_amount
+                elif parameter == PolicyParameter.BASIC_PENSION:
+                    current_value = 6000.0  # Current basic pension is ₹6,000
+                    proposed_value = current_value + increase_amount
+                elif parameter == PolicyParameter.MEDICAL_ALLOWANCE:
+                    current_value = 1000.0  # Current medical allowance is ₹1,000
+                    proposed_value = current_value + increase_amount
+                else:
+                    current_value = increase_amount
+                    proposed_value = increase_amount * 1.5  # Default 50% increase
+            else:
+                # Two numbers - from X to Y
+                current_value = float(groups[0]) if len(groups) > 0 else None
+                proposed_value = float(groups[1]) if len(groups) > 1 else None
+            
+            # Extract years if mentioned
+            years_match = re.search(r"(\d+).*years?", raw_query.lower())
+            years = int(years_match.group(1)) if years_match else 5
+            
+            return PolicyQuery(
+                intent="simulate",
+                parameter=parameter,
+                current_value=current_value,
+                proposed_value=proposed_value,
+                years=min(years, 10),  # Cap at 10 years
+                raw_query=raw_query
+            )
+            
+        except Exception as e:
+            logger.error(f"Parameter extraction error: {e}")
+            return PolicyQuery(intent="simulate", parameter=None, current_value=None, proposed_value=None, raw_query=raw_query)
+    
+    def _handle_simulation_request(self, parsed_query: PolicyQuery, user_id: str) -> Dict[str, Any]:
+        """Handle policy simulation request"""
+        try:
+            # If missing parameters, provide clarification with specific guidance
+            if not all([parsed_query.parameter, parsed_query.current_value, parsed_query.proposed_value]):
+                return self._get_clarification_response(parsed_query.raw_query)
+            
+            # Create scenario
+            scenario = PolicyScenario(
+                parameter=parsed_query.parameter,
+                current_value=parsed_query.current_value,
+                proposed_value=parsed_query.proposed_value,
+                effective_date=datetime.now() + timedelta(days=90),  # 3 months from now
+                affected_population=self._estimate_affected_population(parsed_query.parameter),
+                annual_growth_rate=0.03,
+                inflation_rate=0.06
+            )
+            
+            # Run simulation
+            result = self.simulator.simulate_policy_impact(scenario, parsed_query.years, True)
+            
+            # Format for chat response
+            return self._format_simulation_response(result, parsed_query)
+            
+        except Exception as e:
+            logger.error(f"Simulation request error: {e}")
+            return {
+                "type": "error",
+                "message": f"Simulation failed: {str(e)}",
+                "raw_query": parsed_query.raw_query
+            }
+    
+    def _estimate_affected_population(self, parameter: PolicyParameter) -> int:
+        """Estimate affected population based on parameter type"""
+        population_estimates = {
+            PolicyParameter.DEARNESS_RELIEF: 510000,  # All pensioners
+            PolicyParameter.BASIC_PENSION: 450000,   # Basic pension recipients
+            PolicyParameter.MEDICAL_ALLOWANCE: 510000,  # All pensioners
+            PolicyParameter.PENSION_FACTOR: 510000,
+            PolicyParameter.MINIMUM_PENSION: 200000   # Lower income pensioners
+        }
+        return population_estimates.get(parameter, 400000)
+    
+    def _format_simulation_response(self, result: Dict[str, Any], query: PolicyQuery) -> Dict[str, Any]:
+        """Format simulation results for chat display"""
+        if "error" in result:
+            return {
+                "type": "error",
+                "message": f"Simulation error: {result['error']}"
+            }
+        
+        total_impact = result.get("total_impact", {})
+        projections = result.get("scenario_projections", [])
+        clause_analysis = result.get("clause_analysis", {})
+        
+        # Create summary message
+        summary = f"""
+🎯 **Policy Impact Simulation Results**
+
+**Parameter**: {result.get('parameter_name', 'Unknown')}
+**Change**: {result.get('current_value')} → {result.get('proposed_value')}
+**Effective Date**: {result.get('effective_date', '').split('T')[0]}
+
+📊 **Financial Impact Over {result.get('projection_years')} Years**:
+• **Total Additional Cost**: ₹{total_impact.get('total_additional_cost_crores', 0):.1f} crores
+• **Percentage Increase**: {total_impact.get('percentage_increase', 0):.1f}%
+• **Annual Average**: ₹{total_impact.get('annual_average_impact_crores', 0):.1f} crores
+• **Cost per Beneficiary**: ₹{total_impact.get('cost_per_beneficiary_annual', 0):,.0f} per year
+
+📈 **Year-by-Year Breakdown**:
+"""
+        
+        # Add yearly breakdown
+        for i, proj in enumerate(projections[:3]):  # Show first 3 years
+            summary += f"Year {proj.year}: ₹{proj.impact/10000000:.1f} crores impact ({proj.affected_beneficiaries:,} beneficiaries)\n"
+        
+        if len(projections) > 3:
+            summary += f"... and {len(projections)-3} more years\n"
+        
+        # Add clause information
+        if clause_analysis:
+            clause_diff = clause_analysis.get("clause_diff", {})
+            summary += f"""
+⚖️ **Policy Changes**:
+• **Change Type**: {clause_diff.get('change_type', 'Unknown').title()}
+• **Magnitude**: {clause_diff.get('change_percentage', 0):.1f}% change
+• **Affected Clauses**: {len(clause_analysis.get('affected_clauses', []))} clauses modified
+"""
+        
+        # Add scenario variants
+        variants = result.get("variants", {})
+        charts = []
+        
+        if variants:
+            best_case = sum(p.impact for p in variants.get("best_case", [])) / 10000000
+            worst_case = sum(p.impact for p in variants.get("worst_case", [])) / 10000000
+            base_case = total_impact.get('total_additional_cost_crores', 0)
+            
+            summary += f"""
+📊 **Scenario Analysis**:
+• **Best Case**: ₹{best_case:.1f} crores
+• **Base Case**: ₹{base_case:.1f} crores  
+• **Worst Case**: ₹{worst_case:.1f} crores
+"""
+            
+            # Generate charts
+            try:
+                # Scenario comparison chart
+                scenario_data = {
+                    'best_case': {'total_cost': best_case},
+                    'base_case': {'total_cost': base_case},
+                    'worst_case': {'total_cost': worst_case}
+                }
+                
+                chart_title = f"{result.get('parameter_name', 'Policy')} Impact Analysis"
+                scenario_chart = self.chart_generator.generate_scenario_comparison_chart(
+                    scenario_data, chart_title
+                )
+                
+                if scenario_chart:
+                    charts.append({
+                        "type": "scenario_comparison",
+                        "title": chart_title,
+                        "data": scenario_chart
+                    })
+                
+                # Year-by-year breakdown chart
+                if projections:
+                    # Convert projections to the format expected by chart generator
+                    yearly_data = []
+                    for proj in projections:
+                        yearly_data.append({
+                            'year': proj.year,
+                            'impact': proj.impact / 10000000,  # Convert to crores
+                            'beneficiaries': proj.affected_beneficiaries
+                        })
+                    
+                    trend_chart = self.chart_generator.generate_yearly_breakdown_chart(
+                        yearly_data, f"{result.get('parameter_name', 'Policy')} 5-Year Impact"
+                    )
+                    
+                    if trend_chart:
+                        charts.append({
+                            "type": "yearly_trend", 
+                            "title": "5-Year Financial Impact Trend",
+                            "data": trend_chart
+                        })
+                        
+            except Exception as e:
+                logger.error(f"Chart generation error: {e}")
+        
+        return {
+            "type": "policy_simulation",
+            "message": summary,
+            "simulation_id": result.get("scenario_id"),
+            "detailed_results": result,
+            "charts": charts,
+            "export_options": ["CSV", "PDF", "JSON"],
+            "follow_up_suggestions": [
+                "Compare with other policy scenarios",
+                "Analyze implementation timeline",
+                "Export detailed evidence pack",
+                "Simulate different effective dates"
+            ]
+        }
+    
+    def _get_interactive_form(self, parsed_query: PolicyQuery) -> Dict[str, Any]:
+        """Provide interactive form for missing parameters"""
+        available_parameters = [
+            {"id": "dearness_relief", "name": "Dearness Relief (%)", "current": 12.0, "unit": "%"},
+            {"id": "basic_pension", "name": "Basic Pension (₹)", "current": 6000, "unit": "₹"},
+            {"id": "medical_allowance", "name": "Medical Allowance (₹)", "current": 1000, "unit": "₹"},
+            {"id": "pension_factor", "name": "Pension Factor", "current": 1.0, "unit": "multiplier"},
+            {"id": "minimum_pension", "name": "Minimum Pension (₹)", "current": 3500, "unit": "₹"}
+        ]
+        
+        return {
+            "type": "interactive_form",
+            "message": "I'd be happy to help you simulate policy impact! Please provide the following details:",
+            "form_fields": [
+                {
+                    "name": "parameter",
+                    "label": "Policy Parameter",
+                    "type": "select",
+                    "options": available_parameters,
+                    "required": True
+                },
+                {
+                    "name": "current_value",
+                    "label": "Current Value",
+                    "type": "number",
+                    "required": True
+                },
+                {
+                    "name": "proposed_value", 
+                    "label": "Proposed Value",
+                    "type": "number",
+                    "required": True
+                },
+                {
+                    "name": "years",
+                    "label": "Projection Years",
+                    "type": "number",
+                    "default": 5,
+                    "min": 1,
+                    "max": 10
+                }
+            ],
+            "examples": [
+                "Simulate DR increase from 12% to 18% over 5 years",
+                "What if basic pension changes from ₹6000 to ₹8000?",
+                "Impact of medical allowance increase to ₹2000"
+            ]
+        }
+    
+    def _handle_comparison_request(self, parsed_query: PolicyQuery, user_id: str) -> Dict[str, Any]:
+        """Handle policy comparison request"""
+        sample_comparisons = [
+            {
+                "name": "DR vs Basic Pension Increase",
+                "scenarios": [
+                    {"parameter": "DR", "change": "12% → 18%", "impact": "₹85.2 crores"},
+                    {"parameter": "Basic Pension", "change": "₹6000 → ₹8000", "impact": "₹108.0 crores"}
+                ],
+                "recommendation": "DR increase is more cost-effective"
+            },
+            {
+                "name": "Short vs Long Term Impact",
+                "scenarios": [
+                    {"period": "3 years", "total_impact": "₹150.5 crores"},
+                    {"period": "10 years", "total_impact": "₹628.3 crores"}
+                ],
+                "recommendation": "Long-term planning essential"
+            }
+        ]
+        
+        return {
+            "type": "policy_comparison",
+            "message": "Here are some policy comparison examples. Would you like to compare specific scenarios?",
+            "comparisons": sample_comparisons,
+            "custom_comparison": {
+                "description": "I can help you compare up to 5 different policy scenarios",
+                "example": "Compare DR increase vs pension boost vs medical allowance increase"
+            }
+        }
+    
+    def _get_help_response(self) -> Dict[str, Any]:
+        """Provide help information"""
+        return {
+            "type": "help",
+            "message": """
+🎯 **Policy Impact Simulator Help**
+
+I can help you simulate the financial impact of government policy changes. Here's what I can do:
+
+**📊 Simulation Capabilities**:
+• Dearness Relief (DR) changes
+• Basic pension adjustments  
+• Medical allowance modifications
+• Pension factor changes
+• Minimum pension guarantees
+
+**💬 How to Ask**:
+• "Simulate DR increase from 12% to 18%"
+• "What if basic pension changes from ₹6000 to ₹8000?"
+• "Impact of medical allowance increase to ₹2000 over 5 years"
+• "Compare DR increase vs pension boost"
+
+**📈 What You Get**:
+• Total financial impact over 3-10 years
+• Year-by-year breakdown
+• Best/base/worst case scenarios
+• Affected population estimates
+• Policy clause analysis
+• Implementation timeline
+• Exportable evidence pack
+
+**🚀 Quick Examples**:
+Try asking: "Show me the impact of increasing DR by 6%"
+""",
+            "quick_actions": [
+                {"label": "Sample DR Simulation", "query": "simulate DR from 12 to 18 percent"},
+                {"label": "Basic Pension Impact", "query": "what if basic pension increases to 8000"},
+                {"label": "Compare Scenarios", "query": "compare policy scenarios"},
+                {"label": "View Parameters", "query": "show available policy parameters"}
+            ]
+        }
+    
+    def _get_clarification_response(self, query: str) -> Dict[str, Any]:
+        """Request clarification for unclear queries"""
+        
+        # Provide specific guidance based on the query content
+        query_lower = query.lower()
+        
+        if "da" in query_lower or "dearness allowance" in query_lower or "dr" in query_lower:
+            specific_message = """🎯 **DA/DR Impact Analysis**
+
+I can help you analyze the Dearness Allowance (DA) impact! To provide accurate calculations, please specify:
+
+📊 **Required Details:**
+• **Current DA Rate**: What's the existing DA percentage? (e.g., 12%)
+• **Proposed DA Rate**: What should the new DA be? (e.g., 18% for a 6% increase)
+• **Base Pension Amount**: What's the basic pension amount? (e.g., ₹6,000)
+• **Analysis Period**: How many years to analyze? (default: 5 years)
+
+💡 **Quick Examples:**
+• "Show DA impact from 12% to 18% for pension ₹6000"
+• "Analyze 6% DA increase from current 12% to 18%"
+• "DA simulation: current 12%, increase to 18%, basic pension ₹6000"
+
+📈 **What You'll Get:**
+• Financial impact over 5 years with charts
+• Cost per beneficiary calculations  
+• Best/Base/Worst case scenarios
+• Implementation timeline and evidence pack"""
+            
+        elif "pension" in query_lower and ("basic" in query_lower or "minimum" in query_lower):
+            specific_message = """🎯 **Basic Pension Impact Analysis**
+
+I can help analyze basic pension changes! Please provide:
+
+📊 **Required Details:**
+• **Current Basic Pension**: What's the existing amount? (e.g., ₹6,000)
+• **Proposed Basic Pension**: What should the new amount be? (e.g., ₹8,000)
+• **Analysis Period**: How many years to analyze? (default: 5 years)
+
+💡 **Quick Examples:**
+• "Show basic pension impact from ₹6000 to ₹8000"
+• "Analyze pension increase to ₹8000 over 5 years"
+• "Basic pension simulation: current ₹6000, increase to ₹8000"
+
+📈 **What You'll Get:**
+• Financial impact projections with charts
+• Affected population estimates
+• Cost analysis and implementation timeline"""
+            
+        else:
+            specific_message = """🎯 **Policy Impact Simulation Help**
+
+I understand you want to analyze policy impact! To provide accurate calculations, please specify:
+
+📊 **Choose Your Analysis:**
+• **DA/DR Changes**: Dearness Allowance adjustments (e.g., "DA from 12% to 18%")
+• **Basic Pension**: Minimum pension amount changes (e.g., "Pension from ₹6000 to ₹8000")
+• **Medical Allowance**: Healthcare support changes (e.g., "Medical allowance to ₹1500")
+
+💡 **Format Your Request:**
+Include: Current value → Proposed value → Base amount (if applicable)
+
+📈 **Quick Examples:**
+• "Show DA impact from 12% to 18% for pension ₹6000"
+• "Analyze basic pension increase from ₹6000 to ₹8000"
+• "Medical allowance impact from ₹1000 to ₹1500" """
+        
+        return {
+            "type": "clarification",
+            "message": specific_message,
+            "original_query": query,
+            "suggestions": [
+                "📊 Use the format: 'Show [policy] impact from [current] to [proposed]'",
+                "📈 Include specific numbers and amounts",
+                "⏱️ Specify time period if different from 5 years"
+            ],
+            "quick_actions": [
+                {"text": "📈 DA Analysis Example", "query": "Show DA impact from 12% to 18% for pension ₹6000"},
+                {"text": "💰 Pension Analysis Example", "query": "Show basic pension impact from ₹6000 to ₹8000"},
+                {"text": "📋 Start Interactive Form", "query": "start scenario analysis"}
+            ]
+        }
+
+    def _handle_scenario_analysis_request(self, parsed_query: PolicyQuery, user_id: str) -> Dict[str, Any]:
+        """Handle general scenario analysis requests"""
+        return {
+            "type": "scenario_analysis_help",
+            "message": """🎯 **Scenario Analysis for Rajasthan Pension Policies**
+
+I can help you analyze different scenarios for pension policy changes. Here are the most common analyses:
+
+📊 **Available Scenario Analyses:**
+• **Dearness Relief (DR)**: Analyze inflation adjustments (current: 12%)
+• **Basic Pension**: Analyze minimum pension changes (current: ₹6,000)  
+• **Medical Allowance**: Analyze healthcare support changes (current: ₹1,000)
+• **Pension Factor**: Analyze salary multiplier changes (current: 1.0x)
+
+💬 **How to Request Analysis:**
+• "Simulate DR increase from 12% to 18% over 5 years"
+• "What if basic pension increases to ₹8,000?"
+• "Compare best and worst case scenarios for medical allowance"
+
+📈 **What You'll Get:**
+• Financial impact projections (3-10 years)
+• Best/Base/Worst case scenarios  
+• Affected population estimates
+• Implementation timeline and complexity
+• Exportable evidence packs
+
+🚀 **Try These Examples:**""",
+            "quick_actions": [
+                {"text": "📈 Analyze DR Scenarios", "query": "Show DR scenario analysis from 12% to 18%"},
+                {"text": "💰 Analyze Pension Scenarios", "query": "Show basic pension scenarios from 6000 to 8000"},
+                {"text": "🏥 Analyze Medical Allowance", "query": "Show medical allowance scenarios"},
+                {"text": "📋 Start Interactive Form", "query": "start scenario analysis"}
+            ]
+        }
+
+    def _start_interactive_form(self, user_id: str) -> Dict[str, Any]:
+        """Start interactive scenario analysis form"""
+        try:
+            from scenario_chat_form import start_scenario_analysis_form
+            return start_scenario_analysis_form(user_id)
+        except Exception as e:
+            logger.error(f"Interactive form start failed: {e}")
+            return {
+                "type": "error",
+                "message": "Sorry, I couldn't start the interactive form. Let me help you with a quick simulation instead.",
+                "fallback_form": self._get_clarification_response("")
+            }
+
+# Usage integration function
+def process_policy_chat_query(query: str, user_id: str = "default") -> Dict[str, Any]:
+    """
+    Main function to process policy-related chat queries
+    Use this in your main chat system
+    """
+    interface = PolicySimulatorChatInterface()
+    return interface.process_policy_query(query, user_id)

policy_impact_simulator.py

@@ -0,0 +1,475 @@
+"""
+Policy Impact Simulator Service
+Analyzes policy changes and their financial/social impact over time periods
+"""
+
+import json
+import logging
+from typing import Dict, List, Any, Optional, Tuple
+from datetime import datetime, timedelta
+import pandas as pd
+import numpy as np
+from dataclasses import dataclass
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+class PolicyParameter(Enum):
+    """Policy parameters that can be simulated"""
+    PENSION_FACTOR = "pension_factor"
+    DEARNESS_RELIEF = "dearness_relief"
+    BASIC_PENSION = "basic_pension"
+    MINIMUM_PENSION = "minimum_pension"
+    COMMUTATION_FACTOR = "commutation_factor"
+    MEDICAL_ALLOWANCE = "medical_allowance"
+    FAMILY_PENSION = "family_pension"
+    GRATUITY_LIMIT = "gratuity_limit"
+    HRA_PERCENTAGE = "hra_percentage"
+    AGE_LIMIT = "retirement_age"
+
+class ScenarioType(Enum):
+    """Types of scenarios for impact analysis"""
+    BEST_CASE = "best"
+    BASE_CASE = "base"
+    WORST_CASE = "worst"
+
+@dataclass
+class PolicyScenario:
+    """Configuration for a policy scenario"""
+    parameter: PolicyParameter
+    current_value: float
+    proposed_value: float
+    effective_date: datetime
+    affected_population: int
+    annual_growth_rate: float = 0.03  # Default 3% annual growth
+    inflation_rate: float = 0.06  # Default 6% inflation
+
+@dataclass
+class ImpactProjection:
+    """Financial impact projection"""
+    year: int
+    baseline_cost: float
+    scenario_cost: float
+    impact: float
+    affected_beneficiaries: int
+    notes: str
+
+class PolicyImpactSimulator:
+    """Simulates financial and social impact of policy changes"""
+    
+    def __init__(self):
+        self.policy_definitions = self._load_policy_definitions()
+        self.historical_data = self._load_historical_data()
+        
+    def _load_policy_definitions(self) -> Dict[PolicyParameter, Dict]:
+        """Load policy parameter definitions and constraints"""
+        return {
+            PolicyParameter.PENSION_FACTOR: {
+                "name": "Pension Factor",
+                "description": "Multiplier for calculating monthly pension",
+                "unit": "multiplier",
+                "typical_range": (0.5, 2.0),
+                "current_rajasthan": 1.0,
+                "impact_type": "direct_benefit"
+            },
+            PolicyParameter.DEARNESS_RELIEF: {
+                "name": "Dearness Relief (DR)",
+                "description": "Percentage increase to counter inflation",
+                "unit": "percentage",
+                "typical_range": (0, 50),
+                "current_rajasthan": 12.0,
+                "impact_type": "cost_adjustment"
+            },
+            PolicyParameter.BASIC_PENSION: {
+                "name": "Basic Pension Amount",
+                "description": "Minimum pension amount per month",
+                "unit": "rupees",
+                "typical_range": (3000, 15000),
+                "current_rajasthan": 6000,
+                "impact_type": "direct_benefit"
+            },
+            PolicyParameter.MINIMUM_PENSION: {
+                "name": "Minimum Pension Guarantee",
+                "description": "Guaranteed minimum pension amount",
+                "unit": "rupees",
+                "typical_range": (2000, 10000),
+                "current_rajasthan": 3500,
+                "impact_type": "safety_net"
+            },
+            PolicyParameter.MEDICAL_ALLOWANCE: {
+                "name": "Medical Allowance",
+                "description": "Monthly medical expense allowance",
+                "unit": "rupees",
+                "typical_range": (500, 5000),
+                "current_rajasthan": 1000,
+                "impact_type": "healthcare_benefit"
+            }
+        }
+    
+    def _load_historical_data(self) -> Dict:
+        """Load historical policy implementation data"""
+        return {
+            "rajasthan_pensioners": {
+                "2020": 450000,
+                "2021": 465000,
+                "2022": 480000,
+                "2023": 495000,
+                "2024": 510000
+            },
+            "average_pension": {
+                "2020": 8500,
+                "2021": 9200,
+                "2022": 9800,
+                "2023": 10400,
+                "2024": 11000
+            },
+            "budget_allocation": {
+                "2020": 3850000000,  # 385 crores
+                "2021": 4280000000,  # 428 crores
+                "2022": 4700000000,  # 470 crores
+                "2023": 5100000000,  # 510 crores
+                "2024": 5600000000   # 560 crores
+            }
+        }
+    
+    def simulate_policy_impact(
+        self, 
+        scenario: PolicyScenario, 
+        years: int = 5,
+        include_variants: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Simulate the impact of a policy change over specified years
+        
+        Args:
+            scenario: Policy scenario configuration
+            years: Number of years to project
+            include_variants: Include best/worst case scenarios
+        
+        Returns:
+            Complete impact analysis with projections and metadata
+        """
+        try:
+            # Generate baseline projections
+            baseline_projections = self._generate_baseline_projections(scenario, years)
+            
+            # Generate scenario projections
+            scenario_projections = self._generate_scenario_projections(scenario, years)
+            
+            # Calculate variants if requested
+            variants = {}
+            if include_variants:
+                variants = self._generate_scenario_variants(scenario, years)
+            
+            # Generate clause differences and timeline
+            clause_analysis = self._analyze_clause_changes(scenario)
+            
+            # Create evidence pack
+            evidence_pack = self._create_evidence_pack(
+                scenario, baseline_projections, scenario_projections, variants
+            )
+            
+            return {
+                "scenario_id": f"policy_sim_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+                "parameter": scenario.parameter.value,
+                "parameter_name": self.policy_definitions[scenario.parameter]["name"],
+                "current_value": scenario.current_value,
+                "proposed_value": scenario.proposed_value,
+                "effective_date": scenario.effective_date.isoformat(),
+                "projection_years": years,
+                "baseline_projections": baseline_projections,
+                "scenario_projections": scenario_projections,
+                "variants": variants,
+                "total_impact": self._calculate_total_impact(baseline_projections, scenario_projections),
+                "clause_analysis": clause_analysis,
+                "evidence_pack": evidence_pack,
+                "generated_at": datetime.now().isoformat(),
+                "assumptions": self._document_assumptions(scenario)
+            }
+            
+        except Exception as e:
+            logger.error(f"Policy simulation error: {e}")
+            return {"error": str(e)}
+    
+    def _generate_baseline_projections(self, scenario: PolicyScenario, years: int) -> List[ImpactProjection]:
+        """Generate baseline (no change) projections"""
+        projections = []
+        base_population = scenario.affected_population
+        current_avg_benefit = self._estimate_current_benefit(scenario)
+        
+        for year in range(1, years + 1):
+            # Account for population growth and inflation
+            year_population = int(base_population * (1 + scenario.annual_growth_rate) ** year)
+            year_benefit = current_avg_benefit * (1 + scenario.inflation_rate) ** year
+            
+            annual_cost = year_population * year_benefit * 12  # Monthly to annual
+            
+            projections.append(ImpactProjection(
+                year=year,
+                baseline_cost=annual_cost,
+                scenario_cost=annual_cost,  # Same for baseline
+                impact=0,
+                affected_beneficiaries=year_population,
+                notes=f"Baseline year {year}: No policy change, inflation adjustment only"
+            ))
+        
+        return projections
+    
+    def _generate_scenario_projections(self, scenario: PolicyScenario, years: int) -> List[ImpactProjection]:
+        """Generate scenario (with change) projections"""
+        projections = []
+        base_population = scenario.affected_population
+        current_benefit = self._estimate_current_benefit(scenario)
+        new_benefit = self._calculate_new_benefit(scenario)
+        
+        for year in range(1, years + 1):
+            year_population = int(base_population * (1 + scenario.annual_growth_rate) ** year)
+            
+            # Baseline cost (what it would have been)
+            baseline_benefit = current_benefit * (1 + scenario.inflation_rate) ** year
+            baseline_cost = year_population * baseline_benefit * 12
+            
+            # Scenario cost (with policy change)
+            scenario_benefit = new_benefit * (1 + scenario.inflation_rate) ** year
+            scenario_cost = year_population * scenario_benefit * 12
+            
+            impact = scenario_cost - baseline_cost
+            
+            projections.append(ImpactProjection(
+                year=year,
+                baseline_cost=baseline_cost,
+                scenario_cost=scenario_cost,
+                impact=impact,
+                affected_beneficiaries=year_population,
+                notes=f"Year {year}: Policy change impact ₹{impact/10000000:.1f} crores"
+            ))
+        
+        return projections
+    
+    def _generate_scenario_variants(self, scenario: PolicyScenario, years: int) -> Dict[str, List[ImpactProjection]]:
+        """Generate best/worst case scenario variants"""
+        variants = {}
+        
+        # Best case: Lower growth, higher efficiency
+        best_scenario = PolicyScenario(
+            parameter=scenario.parameter,
+            current_value=scenario.current_value,
+            proposed_value=scenario.proposed_value,
+            effective_date=scenario.effective_date,
+            affected_population=int(scenario.affected_population * 0.9),  # 10% fewer beneficiaries
+            annual_growth_rate=scenario.annual_growth_rate * 0.8,  # 20% lower growth
+            inflation_rate=scenario.inflation_rate * 0.9  # 10% lower inflation
+        )
+        variants["best_case"] = self._generate_scenario_projections(best_scenario, years)
+        
+        # Worst case: Higher growth, implementation challenges
+        worst_scenario = PolicyScenario(
+            parameter=scenario.parameter,
+            current_value=scenario.current_value,
+            proposed_value=scenario.proposed_value * 1.1,  # 10% higher due to implementation costs
+            effective_date=scenario.effective_date,
+            affected_population=int(scenario.affected_population * 1.2),  # 20% more beneficiaries
+            annual_growth_rate=scenario.annual_growth_rate * 1.3,  # 30% higher growth
+            inflation_rate=scenario.inflation_rate * 1.1  # 10% higher inflation
+        )
+        variants["worst_case"] = self._generate_scenario_projections(worst_scenario, years)
+        
+        return variants
+    
+    def _analyze_clause_changes(self, scenario: PolicyScenario) -> Dict[str, Any]:
+        """Analyze what policy clauses would change"""
+        parameter_def = self.policy_definitions[scenario.parameter]
+        
+        return {
+            "affected_clauses": self._identify_affected_clauses(scenario.parameter),
+            "clause_diff": {
+                "before": f"{parameter_def['name']}: {scenario.current_value} {parameter_def['unit']}",
+                "after": f"{parameter_def['name']}: {scenario.proposed_value} {parameter_def['unit']}",
+                "change_type": "increase" if scenario.proposed_value > scenario.current_value else "decrease",
+                "change_magnitude": abs(scenario.proposed_value - scenario.current_value),
+                "change_percentage": ((scenario.proposed_value - scenario.current_value) / scenario.current_value) * 100
+            },
+            "effective_timeline": {
+                "announcement_date": (scenario.effective_date - timedelta(days=90)).isoformat(),
+                "legislative_process": (scenario.effective_date - timedelta(days=60)).isoformat(),
+                "notification_date": (scenario.effective_date - timedelta(days=30)).isoformat(),
+                "effective_date": scenario.effective_date.isoformat(),
+                "first_payment": (scenario.effective_date + timedelta(days=30)).isoformat()
+            },
+            "legal_references": self._get_legal_references(scenario.parameter)
+        }
+    
+    def _identify_affected_clauses(self, parameter: PolicyParameter) -> List[str]:
+        """Identify which policy clauses would be affected"""
+        clause_mapping = {
+            PolicyParameter.PENSION_FACTOR: [
+                "Rajasthan Civil Services (Pension) Rules, 1996 - Rule 35",
+                "Pension calculation formula - Clause 4.2.1",
+                "Service weightage provisions - Clause 6.1"
+            ],
+            PolicyParameter.DEARNESS_RELIEF: [
+                "Dearness Relief calculation - Rule 42",
+                "Inflation adjustment mechanism - Clause 3.4",
+                "Automatic revision provisions - Rule 43"
+            ],
+            PolicyParameter.BASIC_PENSION: [
+                "Minimum pension guarantee - Rule 28",
+                "Basic pension structure - Clause 2.1",
+                "Pension floor provisions - Rule 29"
+            ],
+            PolicyParameter.MEDICAL_ALLOWANCE: [
+                "Medical benefits - Rule 52",
+                "Healthcare allowance - Clause 8.3",
+                "Medical reimbursement - Rule 53"
+            ]
+        }
+        return clause_mapping.get(parameter, ["General pension provisions"])
+    
+    def _get_legal_references(self, parameter: PolicyParameter) -> List[str]:
+        """Get relevant legal references for the parameter"""
+        references = {
+            PolicyParameter.PENSION_FACTOR: [
+                "Rajasthan Civil Services (Pension) Rules, 1996",
+                "Rajasthan Government Resolution No. F.2(5)FD/Rules/96",
+                "Central Civil Services (Pension) Rules, 2021 - Reference"
+            ],
+            PolicyParameter.DEARNESS_RELIEF: [
+                "Rajasthan Civil Services (Revised Pay) Rules, 2017",
+                "Dearness Allowance calculation guidelines",
+                "RCS(RP) Rules notification dated 15.08.2017"
+            ]
+        }
+        return references.get(parameter, ["Rajasthan Civil Services (Pension) Rules, 1996"])
+    
+    def _estimate_current_benefit(self, scenario: PolicyScenario) -> float:
+        """Estimate current monthly benefit amount"""
+        parameter_def = self.policy_definitions[scenario.parameter]
+        
+        if scenario.parameter == PolicyParameter.BASIC_PENSION:
+            return scenario.current_value
+        elif scenario.parameter == PolicyParameter.PENSION_FACTOR:
+            # Average salary * factor
+            return 25000 * scenario.current_value  # Assumed average salary
+        elif scenario.parameter == PolicyParameter.DEARNESS_RELIEF:
+            # DR percentage of basic pension
+            base_pension = 8000  # Assumed base
+            return base_pension * (scenario.current_value / 100)
+        else:
+            return parameter_def.get("current_rajasthan", 5000)
+    
+    def _calculate_new_benefit(self, scenario: PolicyScenario) -> float:
+        """Calculate new monthly benefit amount after policy change"""
+        if scenario.parameter == PolicyParameter.BASIC_PENSION:
+            return scenario.proposed_value
+        elif scenario.parameter == PolicyParameter.PENSION_FACTOR:
+            return 25000 * scenario.proposed_value
+        elif scenario.parameter == PolicyParameter.DEARNESS_RELIEF:
+            base_pension = 8000
+            return base_pension * (scenario.proposed_value / 100)
+        else:
+            return scenario.proposed_value
+    
+    def _calculate_total_impact(self, baseline: List[ImpactProjection], scenario: List[ImpactProjection]) -> Dict[str, float]:
+        """Calculate total financial impact"""
+        total_additional_cost = sum(proj.impact for proj in scenario)
+        total_baseline_cost = sum(proj.baseline_cost for proj in baseline)
+        
+        return {
+            "total_additional_cost_crores": total_additional_cost / 10000000,  # Convert to crores
+            "total_baseline_cost_crores": total_baseline_cost / 10000000,
+            "percentage_increase": (total_additional_cost / total_baseline_cost) * 100 if total_baseline_cost > 0 else 0,
+            "annual_average_impact_crores": (total_additional_cost / len(scenario)) / 10000000,
+            "cost_per_beneficiary_annual": total_additional_cost / (scenario[0].affected_beneficiaries * len(scenario))
+        }
+    
+    def _create_evidence_pack(self, scenario, baseline, projections, variants) -> Dict[str, Any]:
+        """Create exportable evidence pack"""
+        return {
+            "summary_stats": {
+                "policy_parameter": self.policy_definitions[scenario.parameter]["name"],
+                "change_magnitude": f"{scenario.current_value} → {scenario.proposed_value}",
+                "affected_population": scenario.affected_population,
+                "projection_period": f"{len(projections)} years",
+                "total_impact": f"₹{sum(p.impact for p in projections)/10000000:.1f} crores"
+            },
+            "yearly_breakdown": [
+                {
+                    "year": p.year,
+                    "baseline_crores": p.baseline_cost / 10000000,
+                    "scenario_crores": p.scenario_cost / 10000000,
+                    "impact_crores": p.impact / 10000000,
+                    "beneficiaries": p.affected_beneficiaries
+                }
+                for p in projections
+            ],
+            "scenario_comparison": {
+                "best_case_total": sum(p.impact for p in variants.get("best_case", [])) / 10000000 if variants else 0,
+                "base_case_total": sum(p.impact for p in projections) / 10000000,
+                "worst_case_total": sum(p.impact for p in variants.get("worst_case", [])) / 10000000 if variants else 0
+            },
+            "export_formats": {
+                "csv_data": "Ready for CSV export",
+                "chart_data": "Ready for visualization",
+                "pdf_report": "Formatted for official reporting"
+            }
+        }
+    
+    def _document_assumptions(self, scenario: PolicyScenario) -> Dict[str, Any]:
+        """Document all assumptions used in the simulation"""
+        return {
+            "demographic_assumptions": {
+                "affected_population": scenario.affected_population,
+                "annual_growth_rate": f"{scenario.annual_growth_rate*100:.1f}%",
+                "population_source": "Rajasthan pension department estimates"
+            },
+            "economic_assumptions": {
+                "inflation_rate": f"{scenario.inflation_rate*100:.1f}%",
+                "salary_growth": "Aligned with inflation",
+                "implementation_efficiency": "100% (no leakage assumed)"
+            },
+            "policy_assumptions": {
+                "effective_date": scenario.effective_date.strftime("%Y-%m-%d"),
+                "implementation_delay": "None assumed",
+                "administrative_costs": "Not included in projections",
+                "compliance_rate": "100% (full implementation assumed)"
+            },
+            "data_sources": [
+                "Rajasthan Finance Department budget documents",
+                "Pension disbursement historical data",
+                "National Sample Survey Office reports",
+                "Reserve Bank of India inflation projections"
+            ]
+        }
+
+# Usage example and helper functions
+def create_sample_scenarios() -> List[PolicyScenario]:
+    """Create sample policy scenarios for testing"""
+    return [
+        PolicyScenario(
+            parameter=PolicyParameter.DEARNESS_RELIEF,
+            current_value=12.0,
+            proposed_value=18.0,
+            effective_date=datetime(2025, 4, 1),
+            affected_population=510000,
+            annual_growth_rate=0.03,
+            inflation_rate=0.06
+        ),
+        PolicyScenario(
+            parameter=PolicyParameter.BASIC_PENSION,
+            current_value=6000,
+            proposed_value=8000,
+            effective_date=datetime(2025, 7, 1),
+            affected_population=450000,
+            annual_growth_rate=0.025,
+            inflation_rate=0.055
+        ),
+        PolicyScenario(
+            parameter=PolicyParameter.MEDICAL_ALLOWANCE,
+            current_value=1000,
+            proposed_value=2000,
+            effective_date=datetime(2025, 10, 1),
+            affected_population=510000,
+            annual_growth_rate=0.035,
+            inflation_rate=0.065
+        )
+    ]

policy_simulator_api.py

@@ -0,0 +1,285 @@
+"""
+Policy Impact Simulator API endpoints
+Provides REST API access to policy simulation functionality
+"""
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any
+from datetime import datetime, date
+from enum import Enum
+
+from policy_impact_simulator import (
+    PolicyImpactSimulator, 
+    PolicyScenario, 
+    PolicyParameter,
+    create_sample_scenarios
+)
+
+router = APIRouter(prefix="/api/policy-simulator", tags=["policy-simulator"])
+
+# Pydantic models for API
+class PolicyParameterEnum(str, Enum):
+    pension_factor = "pension_factor"
+    dearness_relief = "dearness_relief"
+    basic_pension = "basic_pension"
+    minimum_pension = "minimum_pension"
+    commutation_factor = "commutation_factor"
+    medical_allowance = "medical_allowance"
+    family_pension = "family_pension"
+    gratuity_limit = "gratuity_limit"
+    hra_percentage = "hra_percentage"
+    retirement_age = "retirement_age"
+
+class PolicySimulationRequest(BaseModel):
+    parameter: PolicyParameterEnum = Field(..., description="Policy parameter to simulate")
+    current_value: float = Field(..., description="Current value of the parameter")
+    proposed_value: float = Field(..., description="Proposed new value")
+    effective_date: date = Field(..., description="When the policy change takes effect")
+    affected_population: int = Field(..., description="Number of people affected")
+    annual_growth_rate: float = Field(0.03, description="Annual population growth rate")
+    inflation_rate: float = Field(0.06, description="Expected inflation rate")
+    projection_years: int = Field(5, description="Number of years to project", ge=1, le=10)
+    include_variants: bool = Field(True, description="Include best/worst case scenarios")
+
+class QuickSimulationRequest(BaseModel):
+    scenario_name: str = Field(..., description="Name of predefined scenario")
+    years: int = Field(5, description="Projection years", ge=1, le=10)
+
+# Initialize simulator
+simulator = PolicyImpactSimulator()
+
+@router.post("/simulate")
+async def simulate_policy_impact(request: PolicySimulationRequest):
+    """
+    Simulate the impact of a policy change
+    
+    Provides comprehensive analysis including:
+    - Baseline vs scenario projections
+    - Best/base/worst case scenarios
+    - Clause analysis and timeline
+    - Exportable evidence pack
+    """
+    try:
+        # Convert API request to internal scenario
+        scenario = PolicyScenario(
+            parameter=PolicyParameter(request.parameter.value),
+            current_value=request.current_value,
+            proposed_value=request.proposed_value,
+            effective_date=datetime.combine(request.effective_date, datetime.min.time()),
+            affected_population=request.affected_population,
+            annual_growth_rate=request.annual_growth_rate,
+            inflation_rate=request.inflation_rate
+        )
+        
+        # Run simulation
+        result = simulator.simulate_policy_impact(
+            scenario=scenario,
+            years=request.projection_years,
+            include_variants=request.include_variants
+        )
+        
+        if "error" in result:
+            raise HTTPException(status_code=500, detail=result["error"])
+        
+        return {
+            "success": True,
+            "simulation_result": result,
+            "api_version": "1.0",
+            "generated_at": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Simulation failed: {str(e)}")
+
+@router.post("/quick-simulate")
+async def quick_simulate(request: QuickSimulationRequest):
+    """
+    Run a quick simulation using predefined scenarios
+    
+    Available scenarios:
+    - dr_increase_6_percent: Increase DR from 12% to 18%
+    - basic_pension_boost: Increase basic pension from ₹6000 to ₹8000
+    - medical_allowance_double: Double medical allowance to ₹2000
+    """
+    try:
+        predefined_scenarios = {
+            "dr_increase_6_percent": PolicyScenario(
+                parameter=PolicyParameter.DEARNESS_RELIEF,
+                current_value=12.0,
+                proposed_value=18.0,
+                effective_date=datetime(2025, 4, 1),
+                affected_population=510000
+            ),
+            "basic_pension_boost": PolicyScenario(
+                parameter=PolicyParameter.BASIC_PENSION,
+                current_value=6000,
+                proposed_value=8000,
+                effective_date=datetime(2025, 7, 1),
+                affected_population=450000
+            ),
+            "medical_allowance_double": PolicyScenario(
+                parameter=PolicyParameter.MEDICAL_ALLOWANCE,
+                current_value=1000,
+                proposed_value=2000,
+                effective_date=datetime(2025, 10, 1),
+                affected_population=510000
+            )
+        }
+        
+        if request.scenario_name not in predefined_scenarios:
+            raise HTTPException(
+                status_code=400, 
+                detail=f"Unknown scenario. Available: {list(predefined_scenarios.keys())}"
+            )
+        
+        scenario = predefined_scenarios[request.scenario_name]
+        result = simulator.simulate_policy_impact(scenario, request.years, True)
+        
+        return {
+            "success": True,
+            "scenario_name": request.scenario_name,
+            "simulation_result": result
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/parameters")
+async def get_policy_parameters():
+    """Get available policy parameters with their definitions"""
+    try:
+        parameters = {}
+        for param in PolicyParameter:
+            param_def = simulator.policy_definitions.get(param, {})
+            parameters[param.value] = {
+                "name": param_def.get("name", param.value),
+                "description": param_def.get("description", ""),
+                "unit": param_def.get("unit", ""),
+                "typical_range": param_def.get("typical_range", (0, 100)),
+                "current_rajasthan": param_def.get("current_rajasthan", 0),
+                "impact_type": param_def.get("impact_type", "benefit")
+            }
+        
+        return {
+            "success": True,
+            "parameters": parameters,
+            "total_count": len(parameters)
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/scenarios/samples")
+async def get_sample_scenarios():
+    """Get sample scenarios for testing and demonstration"""
+    try:
+        samples = create_sample_scenarios()
+        
+        scenarios_data = []
+        for i, scenario in enumerate(samples):
+            scenarios_data.append({
+                "id": f"sample_{i+1}",
+                "parameter": scenario.parameter.value,
+                "parameter_name": simulator.policy_definitions[scenario.parameter]["name"],
+                "current_value": scenario.current_value,
+                "proposed_value": scenario.proposed_value,
+                "effective_date": scenario.effective_date.date().isoformat(),
+                "affected_population": scenario.affected_population,
+                "description": f"Sample scenario: {simulator.policy_definitions[scenario.parameter]['name']} change"
+            })
+        
+        return {
+            "success": True,
+            "sample_scenarios": scenarios_data,
+            "usage": "Use these scenarios with /quick-simulate endpoint"
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/analysis/{simulation_id}")
+async def get_detailed_analysis(simulation_id: str):
+    """Get detailed analysis for a completed simulation"""
+    # This would typically fetch from a database
+    # For now, return a placeholder response
+    return {
+        "success": True,
+        "message": "Detailed analysis endpoint - would fetch stored simulation results",
+        "simulation_id": simulation_id,
+        "note": "In production, this would retrieve complete analysis from database"
+    }
+
+@router.post("/compare")
+async def compare_scenarios(scenarios: List[PolicySimulationRequest]):
+    """Compare multiple policy scenarios side by side"""
+    try:
+        if len(scenarios) > 5:
+            raise HTTPException(status_code=400, detail="Maximum 5 scenarios can be compared")
+        
+        comparison_results = []
+        
+        for i, request in enumerate(scenarios):
+            scenario = PolicyScenario(
+                parameter=PolicyParameter(request.parameter.value),
+                current_value=request.current_value,
+                proposed_value=request.proposed_value,
+                effective_date=datetime.combine(request.effective_date, datetime.min.time()),
+                affected_population=request.affected_population,
+                annual_growth_rate=request.annual_growth_rate,
+                inflation_rate=request.inflation_rate
+            )
+            
+            result = simulator.simulate_policy_impact(scenario, request.projection_years, False)
+            comparison_results.append({
+                "scenario_index": i + 1,
+                "parameter": request.parameter.value,
+                "impact_summary": result.get("total_impact", {}),
+                "first_year_impact": result["scenario_projections"][0].impact if result.get("scenario_projections") else 0
+            })
+        
+        # Create comparison summary
+        total_impacts = [r.get("impact_summary", {}).get("total_additional_cost_crores", 0) for r in comparison_results]
+        
+        return {
+            "success": True,
+            "comparison_count": len(scenarios),
+            "scenarios": comparison_results,
+            "summary": {
+                "highest_impact": max(total_impacts) if total_impacts else 0,
+                "lowest_impact": min(total_impacts) if total_impacts else 0,
+                "total_combined_impact": sum(total_impacts),
+                "recommendation": "Detailed comparison analysis completed"
+            }
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/export/{simulation_id}")
+async def export_simulation_data(
+    simulation_id: str,
+    format: str = Query("json", regex="^(json|csv|pdf)$")
+):
+    """Export simulation results in various formats"""
+    try:
+        # This would typically fetch the simulation from database
+        # For now, return export information
+        
+        export_info = {
+            "json": "Complete simulation data in JSON format",
+            "csv": "Yearly projections and impact data in CSV format",
+            "pdf": "Formatted policy impact report in PDF format"
+        }
+        
+        return {
+            "success": True,
+            "simulation_id": simulation_id,
+            "export_format": format,
+            "description": export_info.get(format, "Unknown format"),
+            "download_url": f"/api/policy-simulator/download/{simulation_id}/{format}",
+            "note": "In production, would generate actual downloadable files"
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

scenario_analysis_service.py

@@ -0,0 +1,602 @@
+import matplotlib.pyplot as plt
+import seaborn as sns
+import plotly.graph_objects as go
+import plotly.express as px
+import pandas as pd
+import numpy as np
+import networkx as nx
+from datetime import datetime, timedelta
+import base64
+import io
+import json
+import logging
+from typing import Dict, List, Optional, Tuple, Any
+import asyncio
+
+logger = logging.getLogger("voicebot")
+
+class ScenarioAnalysisService:
+    def __init__(self):
+        """Initialize the scenario analysis service"""
+        # Set matplotlib to use non-interactive backend
+        plt.switch_backend('Agg')
+        # Set style for better looking plots
+        sns.set_style("whitegrid")
+        plt.style.use('seaborn-v0_8')
+        
+    async def analyze_government_scenario(self, scenario_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Analyze government scenarios and create appropriate visualizations
+        """
+        try:
+            scenario_type = scenario_data.get("type", "").lower()
+            data = scenario_data.get("data", {})
+            title = scenario_data.get("title", "Government Scenario Analysis")
+            
+            logger.info(f"🔍 Analyzing scenario: {scenario_type}")
+            
+            # Route to appropriate analysis method based on scenario type
+            if scenario_type in ["budget", "financial", "expenditure"]:
+                return await self._analyze_budget_scenario(data, title)
+            elif scenario_type in ["policy", "implementation", "timeline"]:
+                return await self._analyze_policy_scenario(data, title)
+            elif scenario_type in ["organization", "hierarchy", "structure"]:
+                return await self._analyze_organizational_scenario(data, title)
+            elif scenario_type in ["performance", "metrics", "kpi"]:
+                return await self._analyze_performance_scenario(data, title)
+            elif scenario_type in ["workflow", "process", "flow"]:
+                return await self._analyze_workflow_scenario(data, title)
+            else:
+                return await self._analyze_general_scenario(data, title, scenario_type)
+                
+        except Exception as e:
+            logger.error(f"❌ Error in scenario analysis: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e),
+                "analysis": "Failed to analyze scenario"
+            }
+    
+    async def _analyze_budget_scenario(self, data: Dict, title: str) -> Dict[str, Any]:
+        """Analyze budget and financial scenarios"""
+        try:
+            # Create sample data if not provided
+            if not data:
+                departments = ['Health', 'Education', 'Infrastructure', 'Defense', 'Social Welfare']
+                budgets = [2500, 3000, 4000, 5000, 1500]
+                data = {"departments": departments, "budgets": budgets}
+            
+            # Create multiple visualizations
+            images = []
+            analysis_text = []
+            
+            # 1. Pie Chart for Budget Distribution
+            fig, ax = plt.subplots(figsize=(10, 8))
+            colors = plt.cm.Set3(np.linspace(0, 1, len(data["departments"])))
+            wedges, texts, autotexts = ax.pie(
+                data["budgets"], 
+                labels=data["departments"], 
+                autopct='%1.1f%%',
+                colors=colors,
+                startangle=90
+            )
+            ax.set_title(f"{title} - Budget Distribution", fontsize=16, fontweight='bold')
+            
+            # Convert to base64
+            buffer = io.BytesIO()
+            plt.savefig(buffer, format='png', bbox_inches='tight', dpi=300)
+            buffer.seek(0)
+            pie_image = base64.b64encode(buffer.getvalue()).decode()
+            images.append({"type": "pie_chart", "data": pie_image})
+            plt.close()
+            
+            # 2. Bar Chart for Budget Comparison
+            fig, ax = plt.subplots(figsize=(12, 8))
+            bars = ax.bar(data["departments"], data["budgets"], color=colors)
+            ax.set_title(f"{title} - Department-wise Budget Allocation", fontsize=16, fontweight='bold')
+            ax.set_xlabel("Departments", fontsize=12)
+            ax.set_ylabel("Budget (in Crores)", fontsize=12)
+            
+            # Add value labels on bars
+            for bar in bars:
+                height = bar.get_height()
+                ax.annotate(f'₹{height}Cr',
+                           xy=(bar.get_x() + bar.get_width() / 2, height),
+                           xytext=(0, 3),
+                           textcoords="offset points",
+                           ha='center', va='bottom')
+            
+            plt.xticks(rotation=45)
+            buffer = io.BytesIO()
+            plt.savefig(buffer, format='png', bbox_inches='tight', dpi=300)
+            buffer.seek(0)
+            bar_image = base64.b64encode(buffer.getvalue()).decode()
+            images.append({"type": "bar_chart", "data": bar_image})
+            plt.close()
+            
+            # Generate analysis
+            total_budget = sum(data["budgets"])
+            max_dept = data["departments"][data["budgets"].index(max(data["budgets"]))]
+            min_dept = data["departments"][data["budgets"].index(min(data["budgets"]))]
+            
+            analysis_text = [
+                f"📊 **Budget Analysis Summary:**",
+                f"• Total Budget: ₹{total_budget} Crores",
+                f"• Highest Allocation: {max_dept} (₹{max(data['budgets'])} Cr)",
+                f"• Lowest Allocation: {min_dept} (₹{min(data['budgets'])} Cr)",
+                f"• Average Allocation: ₹{total_budget/len(data['budgets']):.1f} Crores",
+                "",
+                f"💡 **Key Insights:**",
+                f"• {max_dept} receives {max(data['budgets'])/total_budget*100:.1f}% of total budget",
+                f"• Budget distribution shows focus on {max_dept} and infrastructure development",
+                f"• Consider rebalancing if {min_dept} requires more funding"
+            ]
+            
+            return {
+                "success": True,
+                "analysis": "\n".join(analysis_text),
+                "images": images,
+                "scenario_type": "budget",
+                "total_budget": total_budget
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ Error in budget analysis: {str(e)}")
+            raise e
+    
+    async def _analyze_policy_scenario(self, data: Dict, title: str) -> Dict[str, Any]:
+        """Analyze policy implementation scenarios"""
+        try:
+            # Create timeline visualization
+            if not data:
+                phases = ['Planning', 'Approval', 'Implementation', 'Monitoring', 'Evaluation']
+                durations = [30, 15, 90, 60, 30]  # days
+                data = {"phases": phases, "durations": durations}
+            
+            # Create Gantt chart-like visualization
+            fig, ax = plt.subplots(figsize=(14, 8))
+            
+            # Calculate start dates
+            start_date = datetime.now()
+            start_dates = []
+            current_date = start_date
+            
+            for duration in data["durations"]:
+                start_dates.append(current_date)
+                current_date += timedelta(days=duration)
+            
+            # Create horizontal bar chart
+            colors = plt.cm.viridis(np.linspace(0, 1, len(data["phases"])))
+            for i, (phase, duration, start, color) in enumerate(zip(data["phases"], data["durations"], start_dates, colors)):
+                ax.barh(i, duration, left=(start - start_date).days, color=color, alpha=0.7)
+                ax.text((start - start_date).days + duration/2, i, f'{phase}\n({duration} days)', 
+                       ha='center', va='center', fontweight='bold')
+            
+            ax.set_yticks(range(len(data["phases"])))
+            ax.set_yticklabels(data["phases"])
+            ax.set_xlabel("Timeline (Days from Start)")
+            ax.set_title(f"{title} - Policy Implementation Timeline", fontsize=16, fontweight='bold')
+            ax.grid(axis='x', alpha=0.3)
+            
+            buffer = io.BytesIO()
+            plt.savefig(buffer, format='png', bbox_inches='tight', dpi=300)
+            buffer.seek(0)
+            timeline_image = base64.b64encode(buffer.getvalue()).decode()
+            plt.close()
+            
+            # Create network diagram for stakeholder relationships
+            fig, ax = plt.subplots(figsize=(12, 10))
+            G = nx.Graph()
+            
+            # Add nodes (stakeholders)
+            stakeholders = ['Ministry', 'State Govt', 'Local Bodies', 'Citizens', 'NGOs', 'Private Sector']
+            G.add_nodes_from(stakeholders)
+            
+            # Add edges (relationships)
+            relationships = [
+                ('Ministry', 'State Govt'), ('State Govt', 'Local Bodies'),
+                ('Local Bodies', 'Citizens'), ('Ministry', 'NGOs'),
+                ('Private Sector', 'Ministry'), ('NGOs', 'Citizens')
+            ]
+            G.add_edges_from(relationships)
+            
+            # Draw network
+            pos = nx.spring_layout(G, k=2, iterations=50)
+            nx.draw(G, pos, ax=ax, with_labels=True, node_color='lightblue', 
+                   node_size=3000, font_size=10, font_weight='bold',
+                   edge_color='gray', width=2)
+            
+            ax.set_title(f"{title} - Stakeholder Network", fontsize=16, fontweight='bold')
+            ax.axis('off')
+            
+            buffer = io.BytesIO()
+            plt.savefig(buffer, format='png', bbox_inches='tight', dpi=300)
+            buffer.seek(0)
+            network_image = base64.b64encode(buffer.getvalue()).decode()
+            plt.close()
+            
+            images = [
+                {"type": "timeline", "data": timeline_image},
+                {"type": "network", "data": network_image}
+            ]
+            
+            total_duration = sum(data["durations"])
+            critical_phase = data["phases"][data["durations"].index(max(data["durations"]))]
+            
+            analysis_text = [
+                f"📋 **Policy Implementation Analysis:**",
+                f"• Total Implementation Time: {total_duration} days",
+                f"• Critical Phase: {critical_phase} ({max(data['durations'])} days)",
+                f"• Number of Phases: {len(data['phases'])}",
+                "",
+                f"🔗 **Stakeholder Network:**",
+                f"• {len(stakeholders)} key stakeholders identified",
+                f"• {len(relationships)} critical relationships mapped",
+                "",
+                f"⚠️ **Risk Factors:**",
+                f"• {critical_phase} phase requires most attention",
+                f"• Coordination between stakeholders is crucial",
+                f"• Monitor progress at each phase transition"
+            ]
+            
+            return {
+                "success": True,
+                "analysis": "\n".join(analysis_text),
+                "images": images,
+                "scenario_type": "policy",
+                "total_duration": total_duration
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ Error in policy analysis: {str(e)}")
+            raise e
+    
+    async def _analyze_organizational_scenario(self, data: Dict, title: str) -> Dict[str, Any]:
+        """Analyze organizational structure scenarios"""
+        try:
+            # Create organizational hierarchy chart
+            fig, ax = plt.subplots(figsize=(14, 10))
+            
+            # Create hierarchical layout
+            G = nx.DiGraph()
+            
+            # Sample organizational structure
+            if not data:
+                hierarchy = {
+                    'Secretary': ['Joint Secretary 1', 'Joint Secretary 2'],
+                    'Joint Secretary 1': ['Director 1', 'Director 2'],
+                    'Joint Secretary 2': ['Director 3', 'Director 4'],
+                    'Director 1': ['Deputy Director 1', 'Deputy Director 2'],
+                    'Director 2': ['Deputy Director 3'],
+                    'Director 3': ['Deputy Director 4', 'Deputy Director 5'],
+                    'Director 4': ['Deputy Director 6']
+                }
+                data = {"hierarchy": hierarchy}
+            
+            # Build graph
+            for parent, children in data["hierarchy"].items():
+                for child in children:
+                    G.add_edge(parent, child)
+            
+            # Create hierarchical layout
+            pos = nx.nx_agraph.graphviz_layout(G, prog='dot') if hasattr(nx, 'nx_agraph') else nx.spring_layout(G)
+            
+            # Draw organizational chart
+            nx.draw(G, pos, ax=ax, with_labels=True, node_color='lightcoral',
+                   node_size=4000, font_size=8, font_weight='bold',
+                   edge_color='darkgray', arrows=True, arrowsize=20,
+                   bbox=dict(boxstyle="round,pad=0.3", facecolor="white", alpha=0.8))
+            
+            ax.set_title(f"{title} - Organizational Structure", fontsize=16, fontweight='bold')
+            ax.axis('off')
+            
+            buffer = io.BytesIO()
+            plt.savefig(buffer, format='png', bbox_inches='tight', dpi=300)
+            buffer.seek(0)
+            org_image = base64.b64encode(buffer.getvalue()).decode()
+            plt.close()
+            
+            images = [{"type": "organization_chart", "data": org_image}]
+            
+            # Calculate organizational metrics
+            total_positions = len(G.nodes())
+            levels = len(set(nx.shortest_path_length(G, 'Secretary').values())) if 'Secretary' in G.nodes() else 0
+            span_of_control = sum(len(children) for children in data["hierarchy"].values()) / len(data["hierarchy"])
+            
+            analysis_text = [
+                f"🏢 **Organizational Analysis:**",
+                f"• Total Positions: {total_positions}",
+                f"• Organizational Levels: {levels}",
+                f"• Average Span of Control: {span_of_control:.1f}",
+                "",
+                f"📈 **Structure Insights:**",
+                f"• Hierarchical structure with clear reporting lines",
+                f"• {len(data['hierarchy'])} management positions",
+                f"• Balanced distribution of responsibilities",
+                "",
+                f"💡 **Recommendations:**",
+                f"• Consider flattening structure if span > 7",
+                f"• Ensure clear role definitions at each level",
+                f"• Regular review of reporting relationships"
+            ]
+            
+            return {
+                "success": True,
+                "analysis": "\n".join(analysis_text),
+                "images": images,
+                "scenario_type": "organization",
+                "total_positions": total_positions
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ Error in organizational analysis: {str(e)}")
+            raise e
+    
+    async def _analyze_performance_scenario(self, data: Dict, title: str) -> Dict[str, Any]:
+        """Analyze performance metrics scenarios"""
+        try:
+            # Create performance dashboard
+            if not data:
+                metrics = ['Efficiency', 'Quality', 'Timeliness', 'Cost', 'Satisfaction']
+                current = [75, 82, 68, 85, 78]
+                target = [85, 90, 80, 80, 85]
+                data = {"metrics": metrics, "current": current, "target": target}
+            
+            # Create multi-subplot figure
+            fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(16, 12))
+            
+            # 1. Performance vs Target comparison
+            x = np.arange(len(data["metrics"]))
+            width = 0.35
+            
+            ax1.bar(x - width/2, data["current"], width, label='Current', color='skyblue', alpha=0.8)
+            ax1.bar(x + width/2, data["target"], width, label='Target', color='orange', alpha=0.8)
+            ax1.set_xlabel('Metrics')
+            ax1.set_ylabel('Score (%)')
+            ax1.set_title('Performance vs Target')
+            ax1.set_xticks(x)
+            ax1.set_xticklabels(data["metrics"], rotation=45)
+            ax1.legend()
+            ax1.grid(axis='y', alpha=0.3)
+            
+            # 2. Radar chart
+            angles = np.linspace(0, 2 * np.pi, len(data["metrics"]), endpoint=False)
+            angles = np.concatenate((angles, [angles[0]]))
+            
+            current_scores = data["current"] + [data["current"][0]]
+            target_scores = data["target"] + [data["target"][0]]
+            
+            ax2 = plt.subplot(2, 2, 2, projection='polar')
+            ax2.plot(angles, current_scores, 'o-', linewidth=2, label='Current', color='blue')
+            ax2.fill(angles, current_scores, alpha=0.25, color='blue')
+            ax2.plot(angles, target_scores, 'o-', linewidth=2, label='Target', color='red')
+            ax2.fill(angles, target_scores, alpha=0.25, color='red')
+            ax2.set_xticks(angles[:-1])
+            ax2.set_xticklabels(data["metrics"])
+            ax2.set_title('Performance Radar')
+            ax2.legend()
+            
+            # 3. Gap analysis
+            gaps = [target - current for current, target in zip(data["current"], data["target"])]
+            colors = ['red' if gap > 0 else 'green' for gap in gaps]
+            
+            ax3.bar(data["metrics"], gaps, color=colors, alpha=0.7)
+            ax3.set_xlabel('Metrics')
+            ax3.set_ylabel('Gap (Target - Current)')
+            ax3.set_title('Performance Gap Analysis')
+            ax3.axhline(y=0, color='black', linestyle='-', alpha=0.3)
+            plt.setp(ax3.xaxis.get_majorticklabels(), rotation=45)
+            
+            # 4. Performance trend (simulated)
+            months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun']
+            overall_trend = [70, 72, 75, 76, 78, np.mean(data["current"])]
+            
+            ax4.plot(months, overall_trend, marker='o', linewidth=3, markersize=8, color='green')
+            ax4.set_xlabel('Month')
+            ax4.set_ylabel('Overall Performance (%)')
+            ax4.set_title('Performance Trend')
+            ax4.grid(True, alpha=0.3)
+            
+            plt.tight_layout()
+            
+            buffer = io.BytesIO()
+            plt.savefig(buffer, format='png', bbox_inches='tight', dpi=300)
+            buffer.seek(0)
+            performance_image = base64.b64encode(buffer.getvalue()).decode()
+            plt.close()
+            
+            images = [{"type": "performance_dashboard", "data": performance_image}]
+            
+            # Calculate performance metrics
+            avg_current = np.mean(data["current"])
+            avg_target = np.mean(data["target"])
+            overall_gap = avg_target - avg_current
+            critical_areas = [metric for metric, gap in zip(data["metrics"], gaps) if gap > 10]
+            
+            analysis_text = [
+                f"📊 **Performance Analysis:**",
+                f"• Current Average Performance: {avg_current:.1f}%",
+                f"• Target Average Performance: {avg_target:.1f}%",
+                f"• Overall Performance Gap: {overall_gap:.1f}%",
+                "",
+                f"🔍 **Key Findings:**",
+                f"• Best Performing Area: {data['metrics'][data['current'].index(max(data['current']))]}",
+                f"• Areas Needing Improvement: {', '.join(critical_areas) if critical_areas else 'None critical'}",
+                f"• Performance is {'on track' if overall_gap < 5 else 'needs attention'}",
+                "",
+                f"🎯 **Action Items:**",
+                f"• Focus on areas with gaps > 10%",
+                f"• Maintain strong performance in current best areas",
+                f"• Set monthly improvement targets"
+            ]
+            
+            return {
+                "success": True,
+                "analysis": "\n".join(analysis_text),
+                "images": images,
+                "scenario_type": "performance",
+                "overall_gap": overall_gap
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ Error in performance analysis: {str(e)}")
+            raise e
+    
+    async def _analyze_workflow_scenario(self, data: Dict, title: str) -> Dict[str, Any]:
+        """Analyze workflow and process scenarios"""
+        try:
+            # Create workflow diagram
+            fig, ax = plt.subplots(figsize=(16, 10))
+            
+            # Sample workflow if no data provided
+            if not data:
+                steps = ['Application', 'Verification', 'Approval', 'Processing', 'Dispatch']
+                connections = [('Application', 'Verification'), ('Verification', 'Approval'), 
+                             ('Approval', 'Processing'), ('Processing', 'Dispatch')]
+                times = [2, 5, 3, 7, 1]  # days
+                data = {"steps": steps, "connections": connections, "times": times}
+            
+            # Create workflow graph
+            G = nx.DiGraph()
+            for i, step in enumerate(data["steps"]):
+                G.add_node(step, time=data["times"][i])
+            
+            for connection in data["connections"]:
+                G.add_edge(connection[0], connection[1])
+            
+            # Layout for workflow
+            pos = nx.spring_layout(G, k=3, iterations=50)
+            
+            # Draw workflow
+            node_colors = plt.cm.RdYlGn_r(np.array(data["times"])/max(data["times"]))
+            nx.draw(G, pos, ax=ax, with_labels=True, node_color=node_colors,
+                   node_size=4000, font_size=10, font_weight='bold',
+                   edge_color='darkblue', arrows=True, arrowsize=20,
+                   bbox=dict(boxstyle="round,pad=0.3", facecolor="white", alpha=0.9))
+            
+            # Add time labels
+            for i, (node, (x, y)) in enumerate(pos.items()):
+                ax.text(x, y-0.15, f'{data["times"][i]} days', 
+                       ha='center', va='center', fontsize=8, 
+                       bbox=dict(boxstyle="round,pad=0.2", facecolor="yellow", alpha=0.7))
+            
+            ax.set_title(f"{title} - Workflow Process", fontsize=16, fontweight='bold')
+            ax.axis('off')
+            
+            # Add colorbar for time scale
+            sm = plt.cm.ScalarMappable(cmap=plt.cm.RdYlGn_r, 
+                                     norm=plt.Normalize(vmin=min(data["times"]), vmax=max(data["times"])))
+            sm.set_array([])
+            cbar = plt.colorbar(sm, ax=ax, shrink=0.8)
+            cbar.set_label('Processing Time (days)', rotation=270, labelpad=20)
+            
+            buffer = io.BytesIO()
+            plt.savefig(buffer, format='png', bbox_inches='tight', dpi=300)
+            buffer.seek(0)
+            workflow_image = base64.b64encode(buffer.getvalue()).decode()
+            plt.close()
+            
+            images = [{"type": "workflow_diagram", "data": workflow_image}]
+            
+            # Calculate workflow metrics
+            total_time = sum(data["times"])
+            bottleneck = data["steps"][data["times"].index(max(data["times"]))]
+            fastest_step = data["steps"][data["times"].index(min(data["times"]))]
+            
+            analysis_text = [
+                f"⚡ **Workflow Analysis:**",
+                f"• Total Process Time: {total_time} days",
+                f"• Number of Steps: {len(data['steps'])}",
+                f"• Average Step Time: {total_time/len(data['steps']):.1f} days",
+                "",
+                f"🚦 **Process Insights:**",
+                f"• Bottleneck: {bottleneck} ({max(data['times'])} days)",
+                f"• Fastest Step: {fastest_step} ({min(data['times'])} days)",
+                f"• Process Efficiency: {'Good' if total_time < 20 else 'Needs Improvement'}",
+                "",
+                f"🔧 **Optimization Opportunities:**",
+                f"• Focus on reducing {bottleneck} processing time",
+                f"• Consider parallel processing where possible",
+                f"• Implement automation for routine steps"
+            ]
+            
+            return {
+                "success": True,
+                "analysis": "\n".join(analysis_text),
+                "images": images,
+                "scenario_type": "workflow",
+                "total_time": total_time
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ Error in workflow analysis: {str(e)}")
+            raise e
+    
+    async def _analyze_general_scenario(self, data: Dict, title: str, scenario_type: str) -> Dict[str, Any]:
+        """Analyze general scenarios with basic visualizations"""
+        try:
+            # Create simple visualization
+            fig, ax = plt.subplots(figsize=(12, 8))
+            
+            if not data:
+                categories = ['Category A', 'Category B', 'Category C', 'Category D']
+                values = [25, 35, 20, 20]
+                data = {"categories": categories, "values": values}
+            
+            # Create bar chart
+            colors = plt.cm.tab10(np.linspace(0, 1, len(data["categories"])))
+            bars = ax.bar(data["categories"], data["values"], color=colors, alpha=0.8)
+            
+            ax.set_title(f"{title} - {scenario_type.title()} Analysis", fontsize=16, fontweight='bold')
+            ax.set_xlabel("Categories")
+            ax.set_ylabel("Values")
+            
+            # Add value labels
+            for bar in bars:
+                height = bar.get_height()
+                ax.annotate(f'{height}',
+                           xy=(bar.get_x() + bar.get_width() / 2, height),
+                           xytext=(0, 3),
+                           textcoords="offset points",
+                           ha='center', va='bottom')
+            
+            plt.xticks(rotation=45)
+            ax.grid(axis='y', alpha=0.3)
+            
+            buffer = io.BytesIO()
+            plt.savefig(buffer, format='png', bbox_inches='tight', dpi=300)
+            buffer.seek(0)
+            general_image = base64.b64encode(buffer.getvalue()).decode()
+            plt.close()
+            
+            images = [{"type": "general_analysis", "data": general_image}]
+            
+            total_value = sum(data["values"])
+            max_category = data["categories"][data["values"].index(max(data["values"]))]
+            
+            analysis_text = [
+                f"📊 **{scenario_type.title()} Analysis:**",
+                f"• Total Value: {total_value}",
+                f"• Highest Category: {max_category}",
+                f"• Number of Categories: {len(data['categories'])}",
+                "",
+                f"📈 **Key Insights:**",
+                f"• {max_category} shows the highest value",
+                f"• Distribution across {len(data['categories'])} categories",
+                f"• Further analysis may be needed based on specific requirements"
+            ]
+            
+            return {
+                "success": True,
+                "analysis": "\n".join(analysis_text),
+                "images": images,
+                "scenario_type": scenario_type,
+                "total_value": total_value
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ Error in general analysis: {str(e)}")
+            raise e
+
+# Global instance
+scenario_service = ScenarioAnalysisService()