policy_chat_interface.py

"""
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)